Version 1.0.78 (#1514)

* Exclude If on Else Arm for Conditional Schema

* Test

* ChangeLog

* Version

Author: sinclairzx81

changelog/1.0.0.md

@@ -3,6 +3,8 @@
 ---
 
 ### Version Updates
+- [Revision 1.0.78](https://github.com/sinclairzx81/typebox/pull/1514)
+  - Exclude If on Else Arm for Conditional Schema
 - [Revision 1.0.77](https://github.com/sinclairzx81/typebox/pull/1512)
   - Fix TemplateLiteral Infinite Expansion in Value Processors
 - [Revision 1.0.76](https://github.com/sinclairzx81/typebox/pull/1509)

src/schema/static/if.ts

@@ -34,13 +34,17 @@ import type { XIf } from '../types/if.ts'
 import type { XElse } from '../types/else.ts'
 import type { XThen } from '../types/then.ts'
 
-type XStaticIfReduce<Types extends unknown[], Result extends unknown = never> = (
-  Types extends [infer Left extends unknown, ...infer Right extends unknown[]]
-    ? XStaticIfReduce<Right, Result | Left>
-    : Result
-)
 export type XStaticIf<Stack extends string[], Root extends XSchema, Schema extends XIf, IfSchema extends XSchema,
-  Then extends unknown[] = Schema extends XThen<infer ThenSchema extends XSchema> ? [XStaticSchema<Stack, Root, IfSchema> & XStaticSchema<Stack, Root, ThenSchema>] : [],
-  Else extends unknown[] = Schema extends XElse<infer ElseSchema extends XSchema> ? [...Then, XStaticSchema<Stack, Root, ElseSchema>] : Then,
-  Result extends unknown = Else extends [] ? unknown : XStaticIfReduce<Else>
-> = Result
+  If extends unknown = XStaticSchema<Stack, Root, IfSchema>,
+  Then extends unknown = Schema extends XThen<infer ThenSchema extends XSchema> ? XStaticSchema<Stack, Root, ThenSchema> : never,
+  Else extends unknown = Schema extends XElse<infer ElseSchema extends XSchema> ? XStaticSchema<Stack, Root, ElseSchema> : never,
+  
+  IsThen extends boolean = Schema extends XThen ? true : false,
+  IsElse extends boolean = Schema extends XElse ? true : false,
+  Result extends unknown = (
+    [IsThen, IsElse] extends [true, true] ? (If & Then) | Exclude<Else, If> :
+    [IsThen, IsElse] extends [true, false] ? (If & Then) :
+    [IsThen, IsElse] extends [false, true] ? Exclude<Else, If> :
+    unknown
+  )
+> = Result

tasks.ts

@@ -8,7 +8,7 @@ import { Range } from './task/range/index.ts'
 import { Metrics } from './task/metrics/index.ts'
 import { Task } from 'tasksmith'
 
-const Version = '1.0.77'
+const Version = '1.0.78'
 
 // ------------------------------------------------------------------
 // Build

test/typebox/static/schema/if.ts

@@ -1,22 +1,22 @@
 import { Assert } from 'test'
 import { type XStatic } from 'typebox/schema'
 
-// if does not contribute to inference
+// 'if' alone does not contribute to inference
 Assert.IsExtendsMutual<
   XStatic<{
     if: { type: 'number' }
   }>,
   unknown
 >(true)
-// else/then do not contribute if "if" clause is absent
+// 'else/then' do not contribute if "if" clause not present
 Assert.IsExtendsMutual<
   XStatic<{
     else: { const: 1 }
     then: { const: 2 }
   }>,
   unknown
 >(true)
-// if/then should narrow as (if & then)
+// 'if/then' should narrow as (if & then)
 Assert.IsExtendsMutual<
   XStatic<{
     if: { type: 'number' }
@@ -70,33 +70,95 @@ Assert.IsExtendsMutual<
 Assert.IsExtendsMutual<
   XStatic<{
     if: { type: 'number' }
-    else: {
-      if: { type: 'number' }
-      else: { const: 1 }
-      then: { const: 2 }
-    }
     then: {
       if: { type: 'number' }
       else: { const: 3 }
       then: { const: 4 }
     }
+    else: {
+      if: { type: 'number' }
+      else: { const: 1 }
+      then: { const: 2 }
+    }
   }>,
-  1 | 2 | 3 | 4
+  4
 >(true)
 // multi variant nested if/then/else inference
 Assert.IsExtendsMutual<
   XStatic<{
     if: { type: ['number', 'string'] }
+    then: {
+      if: { type: 'string' }
+      else: { const: 'A' }
+      then: { const: 'B' }
+    }
     else: {
       if: { type: 'number' }
       else: { const: 1 }
       then: { const: 2 }
     }
+  }>,
+  'B'
+>(true)
+// when else arm unreachable, so we evaluate for then only
+Assert.IsExtendsMutual<
+  XStatic<{
+    if: { type: 'number' }
+    then: { const: 1 }
+    else: { const: 2 } // anything reaching else would NOT be number, thus
+    // could never satisfy the constraint of 2.
+  }>,
+  1
+>(true)
+// when else arm is reachable.
+Assert.IsExtendsMutual<
+  XStatic<{
+    if: { type: 'number' }
+    then: { const: 1 }
+    else: { const: 'hello' } // anything NOT number is reachable
+  }>,
+  1 | 'hello'
+>(true)
+// when if arm is illogical, infer as else.
+Assert.IsExtendsMutual<
+  XStatic<{
+    if: { type: 'string' }
+    then: { const: 1 } // illogical
+    else: { const: 2 }
+  }>,
+  2
+>(true)
+// should be distributive over union
+Assert.IsExtendsMutual<
+  XStatic<{
+    type: 'object'
+    required: ['x']
+    properties: {
+      x: { type: 'number' }
+    }
+    if: {
+      properties: {
+        x: { const: 1 }
+      }
+    }
     then: {
-      if: { type: 'string' }
-      else: { const: 'A' }
-      then: { const: 'B' }
+      required: ['y']
+      properties: {
+        y: { const: 2 }
+      }
+    }
+    else: {
+      required: ['z']
+      properties: {
+        z: { const: 3 }
+      }
     }
   }>,
-  1 | 2 | 'A' | 'B'
+  {
+    z: 3
+    x: number
+  } | {
+    x: 1
+    y: 2
+  }
 >(true)