Inference Stack

Author: sinclairzx81

example/index.ts

@@ -1,29 +1,46 @@
 import Type, { type Static } from 'typebox'
+import { Compile } from 'typebox/compile'
+import Format from 'typebox/format'
 import Value from 'typebox/value'
 
-// type JsonValue = ( // Type alias 'JsonValue' circularly references itself.
-//   | JsonValue[]
-//   | Record<string, JsonValue> // fix: Use Record<string, unknown>
-//   | string
-//   | number
-//   | boolean
-//   | null
-// )
-
-
-type A = Static<typeof JsonObject>
-
-const { JsonObject, JsonValue, JsonArray } = Type.Module({
-  JsonArray: Type.Array(Type.Ref('JsonValue')),
-  JsonObject: Type.Record(Type.String(), Type.Ref('JsonValue')),
-  JsonValue: Type.Union([
-    Type.Ref('JsonObject'),
-    Type.Ref('JsonArray'),
-    Type.String(),
-    Type.Number(),
-    Type.Boolean(),
-    Type.Null(),
-  ])
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+const T = Type.Object({
+  x: Type.Number(),
+  y: Type.Number(),
+  z: Type.Number()
 })
 
+// ------------------------------------------------------------------
+// Script
+// ------------------------------------------------------------------
+const S = Type.Script({ T }, `{
+  [K in keyof T]: T[K] | null
+}`)
 
+// ------------------------------------------------------------------
+// Infer
+// ------------------------------------------------------------------
+type T = Static<typeof T>
+type S = Static<typeof S>
+
+// ------------------------------------------------------------------
+// Parse
+// ------------------------------------------------------------------
+
+const R = Value.Parse(T, { x: 1, y: 2, z: 3 })
+
+// ------------------------------------------------------------------
+// Compile
+// ------------------------------------------------------------------
+
+const C = Compile(S)
+
+const X = C.Parse({ x: 1, y: 2, z: 3 })
+
+// ------------------------------------------------------------------
+// Format
+// ------------------------------------------------------------------
+
+const E = Format.IsEmail('user@domain.com')

src/type/types/ref.ts

@@ -32,25 +32,62 @@ import { Memory } from '../../system/memory/index.ts'
 import { type StaticType, type StaticDirection } from './static.ts'
 import { type TSchema, type TSchemaOptions, IsKind } from './schema.ts'
 import { type TProperties } from './properties.ts'
+import { type TObject } from './object.ts'
+import { type TUnknown } from './unknown.ts'
 
+// ------------------------------------------------------------------
+//
+// CyclicGuard
+//
+// This Guard checks if a given Ref already exists in the Stack,
+// indicating recursion. If recursion is found, it ensures the Stack
+// length remains below a safe threshold. 
+//
+// The purpose is to allow recursive types to instantiate up to a
+// reasonable depth (for user feedback) while preventing unbounded
+// recursion. 
+//
+// Note: This Guard is only needed for non-Object types, since
+// TypeScript automatically defers inference for referential
+// mapped property types.
+//
+// ------------------------------------------------------------------
+type CyclicStackLength<Stack extends unknown[], MaxLength extends number, Buffer extends unknown[] = []> = (
+  Stack extends [infer Left, ...infer Right]
+    ? Buffer['length'] extends MaxLength
+      ? false 
+      : CyclicStackLength<Right, MaxLength, [...Buffer, Left]>
+    : true
+)
+type CyclicGuard<Stack extends unknown[], Ref extends string> = (
+  Ref extends Stack[number] ? CyclicStackLength<Stack, 4> : true
+)
 
 // ------------------------------------------------------------------
-// Static
+// StaticRef
+//
+// The inference Stack is appended only when encountering a Ref. If the
+// referenced target is a TObject, the Stack is reset, and TypeScript's
+// built-in inference deferral for referential property types applies.
+//
+// In all other cases, the Ref is pushed onto the Stack and checked
+// with CyclicGuard to ensure recursion is terminated based on the
+// CyclicGuard heuristic. Terminated recursion defaults to Any as an
+// approximation of the expansive type.
+//
 // ------------------------------------------------------------------
-type StaticTerminate<Stack extends unknown[], Ref extends string> = (
-   Stack['length'] extends 6
-    ? true
-    : false
+type StaticGuardedRef<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Ref extends string, Type extends TSchema> = (
+  CyclicGuard<Stack, Ref> extends true
+    ? StaticType<[...Stack, Ref], Direction, Context, This, Type>
+    : any
 )
-export type StaticRef<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Ref extends string, 
-  Result extends unknown = (
-    Ref extends keyof Context 
-      ? StaticTerminate<Stack, Ref> extends false
-        ? StaticType<[...Stack, Ref], Direction, Context, This, Context[Ref]> 
-        : any
-      : unknown
-  )
+export type StaticRef<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Ref extends string,
+  Target extends TSchema = Ref extends keyof Context ? Context[Ref] : TUnknown,
+  Result extends unknown = Target extends TObject
+    ? StaticType<[/* Reset */], Direction, Context, This, Target>
+    : StaticGuardedRef<Stack, Direction, Context, This, Ref, Target>
 > = Result
+
 // ------------------------------------------------------------------
 // Type
 // ------------------------------------------------------------------

test/typebox/static/type/cyclic.ts

@@ -0,0 +1,75 @@
+
+import { type Static, Type } from 'typebox'
+import { Assert } from 'test'
+
+// ------------------------------------------------------------------
+// NonCyclic
+// ------------------------------------------------------------------
+{
+  const NonCyclic = Type.Cyclic({
+    NonCyclic: Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number()
+    })
+  }, 'NonCyclic')
+  type NonCyclic = Static<typeof NonCyclic>
+  // Invariant
+  Assert.IsExtendsMutual<{ x: 1, y: 2, z: false }, NonCyclic>(false)
+  // Extends
+  Assert.IsExtendsMutual<{ x: number, y: number, z: number }, NonCyclic>(true)
+}
+
+// ------------------------------------------------------------------
+// Deep
+//
+// https://github.com/sinclairzx81/typebox/issues/1356
+// ------------------------------------------------------------------
+{
+  const Deep = Type.Cyclic({
+    Deep: Type.Object({
+      deep: Type.Ref('Deep')
+    })
+  }, 'Deep')
+  type Deep = Static<typeof Deep>
+  // Invariant
+  Assert.IsExtends<{ deep: 1 }, Deep>(false)
+  Assert.IsExtends<{ deep: { deep: { deep: 1 } } }, Deep>(false)
+  
+  // Extends
+  Assert.IsExtends<{ deep: any }, Deep>(true)
+  Assert.IsExtends<{ deep: { deep: { deep: any } } }, Deep>(true)
+}
+// ------------------------------------------------------------------
+// JsonValue
+//
+// https://github.com/sinclairzx81/typebox/issues/1356
+// ------------------------------------------------------------------
+{
+  const JsonValue = Type.Cyclic({
+    JsonValue: Type.Union([
+      Type.Record(Type.String(), Type.Ref('JsonValue')),
+      Type.Array(Type.Ref('JsonValue')),
+      Type.String(),
+      Type.Number(),
+      Type.Boolean(),
+      Type.Null(),
+    ])
+  }, 'JsonValue')
+
+  type JsonValue = Static<typeof JsonValue>
+  // Invariant
+  Assert.IsExtends<bigint, JsonValue>(false)
+  Assert.IsExtends<bigint[], JsonValue>(false)
+  Assert.IsExtends<[bigint], JsonValue>(false)
+  Assert.IsExtends<{ x: bigint }, JsonValue>(false)
+
+  // Extends
+  Assert.IsExtends<'A', JsonValue>(true)
+  Assert.IsExtends<1, JsonValue>(true)
+  Assert.IsExtends<true, JsonValue>(true)
+  Assert.IsExtends<null, JsonValue>(true)
+  Assert.IsExtends<null[], JsonValue>(true)
+  Assert.IsExtends<[null], JsonValue>(true)
+  Assert.IsExtends<{ x: null }, JsonValue>(true)
+}