Dependent If Type

Author: sinclairzx81

design/syntax/syntax.ts

@@ -283,6 +283,7 @@ const Base = Runtime.Union([
   Runtime.Ref('Constructor'),
   Runtime.Ref('_Function_'),
   Runtime.Ref('Mapped'),
+  Runtime.Ref('_If_'),
   Runtime.Ref('Options'),
   Runtime.Ref('GenericCall'),
   Runtime.Ref('Reference')
@@ -638,6 +639,14 @@ const Mapped = Runtime.Tuple([
   Runtime.Const(RBrace),
 ])
 // ------------------------------------------------------------------
+// If
+// ------------------------------------------------------------------
+const _If_ = Runtime.Union([
+  Runtime.Tuple([Runtime.Const('if'), Runtime.Ref('Type'), Runtime.Const('then'), Runtime.Ref('Type'), Runtime.Const('else'), Runtime.Ref('Type')]),
+  Runtime.Tuple([Runtime.Const('if'), Runtime.Ref('Type'), Runtime.Const('then'), Runtime.Ref('Type')]),
+  Runtime.Tuple([Runtime.Const('if'), Runtime.Ref('Type'), Runtime.Const('else'), Runtime.Ref('Type')])
+])
+// ------------------------------------------------------------------
 // Options
 // ------------------------------------------------------------------
 const Options = Runtime.Tuple([
@@ -1008,6 +1017,9 @@ export const SyntaxModule = new Runtime.Module({
   MappedOptional,
   MappedAs,
   Mapped,
+
+  _If_,
+
   Reference,
   Options,
 

example/index.ts

@@ -1,70 +1,27 @@
-import Compile from 'typebox/compile'
-import System from 'typebox/system'
-import Guard from 'typebox/guard'
-import Format from 'typebox/format'
-import Schema from 'typebox/schema'
-import Value from 'typebox/value'
 import Type from 'typebox'
 
-// ------------------------------------------------------------------
-// Settings
-// ------------------------------------------------------------------
+const { A } = Type.Script(`
+  type A = {
+    x: number
+    y: number
+  } & if { x: 1 } then { y: 2 } else
+      if { x: 2 } then { y: 3 } else
+      never
+`)
 
-System.Settings.Set({ enumerableKind: false })
 
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
+type A = Type.Static<typeof A> 
 
-const A = Guard.GraphemeCount('type-📦')      // 6
-const B = Guard.HasPropertyKey({ x: 1 }, 'x') // true
+function test(value: Type.Static<typeof A>) {}
 
-// ------------------------------------------------------------------
-// Type
-// ------------------------------------------------------------------
+test({ x: 1, y: 2 })  // ok
+test({ x: 2, y: 3 })  // ok
 
-const T = Type.Object({
-  x: Type.Number(),
-  y: Type.Number(),
-  z: Type.Number()
-})
+test({ x: 1, y: -1 }) // error: Type '-1' is not assignable to type '2 | 3'
+test({ x: 2, y: -1 }) // error: Type '-1' is not assignable to type '2 | 3'
 
-// ------------------------------------------------------------------
-// Script
-// ------------------------------------------------------------------
 
-const S = Type.Script({ T }, `{
-  [K in keyof T]: T[K] | null
-}`)
 
-// ------------------------------------------------------------------
-// Infer
-// ------------------------------------------------------------------
+console.dir(A)
 
-type T = Type.Static<typeof T>
-type S = Type.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')
-
-// ------------------------------------------------------------------
-// Schema
-// ------------------------------------------------------------------
-
-const D = Schema.Parse({ const: 'hello' }, 'hello')

src/type/script/mapping.ts

@@ -1208,6 +1208,25 @@ export function MappedMapping(input: [unknown, unknown, unknown, unknown, unknow
   )
 }
 // -------------------------------------------------------------------
+// _If_: ['if', Type, 'then', Type, 'else', Type] | ['if', Type, 'then', Type] | ['if', Type, 'else', Type]
+// -------------------------------------------------------------------
+export type T_If_Mapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown]> = (
+  Input extends ['if', infer If extends T.TSchema, 'then', infer Then extends T.TSchema, 'else', infer Else extends T.TSchema]
+    ? T.TIf<If, Then, Else> :
+  Input extends ['if', infer If extends T.TSchema, 'then', infer Then extends T.TSchema]
+    ? T.TIf<If, Then, T.TNever> :
+  Input extends ['if', infer If extends T.TSchema, 'else', infer Else extends T.TSchema]
+    ? T.TIf<If, T.TNever, Else> :
+  never
+)
+export function _If_Mapping(input: [unknown, unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown]): unknown {
+  return (
+    Guard.IsEqual(input.length, 6) ? T.If(input[1] as T.TSchema, input[3] as T.TSchema, input[5] as T.TSchema) :
+    Guard.IsEqual(input[2], 'then') ? T.If(input[1] as T.TSchema, input[3] as T.TSchema, T.Never()) :
+    T.If(input[1] as T.TSchema, T.Never(), input[3] as T.TSchema)
+  )
+}
+// -------------------------------------------------------------------
 // Reference: <Ident>
 // -------------------------------------------------------------------
 export type TReferenceMapping<Input extends string,