Version 1.1.27 (#1580)

* Inference Optimization for XStaticProperties

* Fix Evaluation for Conditional Keyword Evaluation

* ChangeLog

* Version

Author: sinclairzx81

changelog/1.1.0.md

@@ -3,6 +3,8 @@
 ---
 
 ### Version Updates
+- [Revision 1.1.27](https://github.com/sinclairzx81/typebox/pull/1580)
+  - Inference Optimization for XStaticProperties
 - [Revision 1.1.26](https://github.com/sinclairzx81/typebox/pull/1578)
   - Presentation Update for Record Inference
 - [Revision 1.1.25](https://github.com/sinclairzx81/typebox/pull/1577)

example/index.ts

@@ -67,4 +67,4 @@ const E = Format.IsEmail('user@domain.com')
 // Schema
 // ------------------------------------------------------------------
 
-const D = Schema.Check({ type: 'string' }, 'hello')
+const D = Schema.Parse({ const: 'hello' }, 'hello')

src/schema/static/properties.ts

@@ -29,26 +29,79 @@ THE SOFTWARE.
 // deno-fmt-ignore-file
 
 import type { XSchema } from '../types/schema.ts'
+import type { XRequired } from '../types/required.ts'
 import type { XStaticSchema } from './schema.ts'
-import type { XIsReadonly } from './~readonly.ts'
 
 // ------------------------------------------------------------------
-// ReadonlyOptionalProperties
+// IsReadonly
 // ------------------------------------------------------------------
-type XReadonlyOptionalProperties<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema>> = {
-  readonly [Key in keyof Properties as XIsReadonly<Properties[Key]> extends true ? Key : never]?: XStaticSchema<Stack, Root, Properties[Key]>
-}
+type XIsReadonly<Schema extends XSchema> = (
+  Schema extends { readOnly: true } ? true :
+  Schema extends { '~readonly': true } ? true : // review
+  false
+)
+// ------------------------------------------------------------------
+// RequiredArray
+// ------------------------------------------------------------------
+type XRequiredArray<Schema extends XSchema,
+  Result extends PropertyKey[] = Schema extends XRequired<infer Keys extends string[]> ? Keys : []
+> = Result
+// ------------------------------------------------------------------
+// Keys
+// ------------------------------------------------------------------
+type XReadonlyKeys<Properties extends Record<PropertyKey, XSchema>,
+  ReadonlyProperties extends Record<PropertyKey, unknown> = { [Key in keyof Properties as XIsReadonly<Properties[Key]> extends true ? Key : never]: unknown },
+  Result extends PropertyKey = keyof ReadonlyProperties
+> = Result
+type XRequiredKeys<Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[], 
+  Result extends PropertyKey = RequiredArray extends [] ? never : Extract<keyof Properties, RequiredArray[number]>
+> = Result
+type XUnknownKeys<Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[],
+  Result extends PropertyKey = Exclude<RequiredArray[number], keyof Properties>
+> = Result
+type XOptionalKeys<Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[],
+  Result extends PropertyKey = RequiredArray extends [] ? keyof Properties : Exclude<keyof Properties, RequiredArray[number]>
+> = Result
 // ------------------------------------------------------------------
-// OptionalProperties
+// Properties
 // ------------------------------------------------------------------
-type XOptionalProperties<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema>> = {
-  [Key in keyof Properties as XIsReadonly<Properties[Key]> extends true ? never : Key]?: XStaticSchema<Stack, Root, Properties[Key]>
+type XReadonlyOptionalProperties<Stack extends string[], Root extends XSchema, OptionalKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
+  readonly [Key in Extract<keyof Properties, OptionalKeys>]?: XStaticSchema<Stack, Root, Properties[Key]>
+}
+type XReadonlyRequiredProperties<Stack extends string[], Root extends XSchema, RequiredKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
+  readonly [Key in Extract<keyof Properties, RequiredKeys>]: XStaticSchema<Stack, Root, Properties[Key]>
+}
+type XOptionalProperties<Stack extends string[], Root extends XSchema, OptionalKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
+  [Key in Extract<keyof Properties, OptionalKeys>]?: XStaticSchema<Stack, Root, Properties[Key]>
+}
+type XRequiredProperties<Stack extends string[], Root extends XSchema, RequiredKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
+  [Key in Extract<keyof Properties, RequiredKeys>]: XStaticSchema<Stack, Root, Properties[Key]>
+}
+type XUnknownProperties<UnknownKeys extends PropertyKey> = {
+  [Key in UnknownKeys]: unknown
 }
 // ------------------------------------------------------------------
 // XStaticProperties
 // ------------------------------------------------------------------
-export type XStaticProperties<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema>,
-  ReadonlyOptional extends Record<PropertyKey, unknown> = XReadonlyOptionalProperties<Stack, Root, Properties>,
-  Optional extends Record<PropertyKey, unknown> = XOptionalProperties<Stack, Root, Properties>,
-  Result extends Record<PropertyKey, unknown> = ReadonlyOptional & Optional
+export type XStaticProperties<Stack extends string[], Root extends XSchema, Schema extends XSchema, Properties extends Record<PropertyKey, XSchema>,
+  RequiredArray extends string[] = XRequiredArray<Schema>,
+  // Keys
+  ReadonlyKeys extends PropertyKey = XReadonlyKeys<Properties>,
+  OptionalKeys extends PropertyKey = XOptionalKeys<Properties, RequiredArray>,
+  RequiredKeys extends PropertyKey = XRequiredKeys<Properties, RequiredArray>,
+  UnknownKeys extends PropertyKey = XUnknownKeys<Properties, RequiredArray>,
+  // Properties
+  ReadonlyOptionalProperties extends Record<PropertyKey, unknown> = XReadonlyOptionalProperties<Stack, Root, Extract<OptionalKeys, ReadonlyKeys>, Properties>,
+  ReadonlyRequiredProperties extends Record<PropertyKey, unknown> = XReadonlyRequiredProperties<Stack, Root, Extract<RequiredKeys, ReadonlyKeys>, Properties>,
+  OptionalProperties extends Record<PropertyKey, unknown> = XOptionalProperties<Stack, Root, Exclude<OptionalKeys, ReadonlyKeys>, Properties>,
+  RequiredProperties extends Record<PropertyKey, unknown> = XRequiredProperties<Stack, Root, Exclude<RequiredKeys, ReadonlyKeys>, Properties>,
+  UnknownProperties extends Record<PropertyKey, unknown> = XUnknownProperties<UnknownKeys>,
+  // Properties
+  Result extends Record<PropertyKey, unknown> = (
+    ReadonlyOptionalProperties &
+    ReadonlyRequiredProperties &
+    OptionalProperties & 
+    RequiredProperties & 
+    UnknownProperties
+  )
 > = Result

src/schema/static/required.ts

@@ -31,38 +31,11 @@ THE SOFTWARE.
 
 import type { XSchema } from '../types/schema.ts'
 import type { XProperties } from '../types/properties.ts'
-import type { XIsReadonly } from './~readonly.ts'
-import type { XStaticSchema } from './schema.ts'
 
-// ------------------------------------------------------------------
-// ResolveProperties
-// ------------------------------------------------------------------
-type XResolveProperties<Schema extends XSchema, Result extends Record<PropertyKey, XSchema> = (
-  Schema extends XProperties<infer Properties extends Record<PropertyKey, XSchema>> ? Properties : {}
-)> = Result
-// ------------------------------------------------------------------
-// FromKey
-// ------------------------------------------------------------------
-type XFromKey<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema>, Key extends string,
-  Readonly extends boolean = Key extends keyof Properties ? XIsReadonly<Properties[Key]> : false,
-  Value extends unknown = Key extends keyof Properties ? XStaticSchema<Stack, Root, Properties[Key]> : unknown,
-  Result extends Record<PropertyKey, unknown> = (
-    Readonly extends true
-    ? { readonly [_ in Key]: Value }
-    : { [_ in Key]: Value }
-)> = Result
-// ------------------------------------------------------------------
-// FromKeys
-// ------------------------------------------------------------------
-type XFromKeys<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema>, Keys extends string[], Result extends Record<PropertyKey, unknown> = {}> = (
-  Keys extends [infer Left extends string, ...infer Right extends string[]]
-    ? XFromKeys<Stack, Root, Properties, Right, Result & XFromKey<Stack, Root, Properties, Left>>
-    : Result
-)
 // ------------------------------------------------------------------
 // XStaticRequired
 // ------------------------------------------------------------------
 export type XStaticRequired<Stack extends string[], Root extends XSchema, Schema extends XSchema, Keys extends string[],
-  Properties extends Record<PropertyKey, XSchema> = XResolveProperties<Schema>,
-  Result extends Record<PropertyKey, unknown> = XFromKeys<Stack, Root, Properties, Keys>
+  // note: We only produce an property set if 'required' is present without 'properties'
+  Result extends Record<PropertyKey, unknown> = Schema extends XProperties ? {} : Record<Keys[number], unknown>
 > = Result

src/schema/static/schema.ts

@@ -44,7 +44,6 @@ import type { XRequired } from '../types/required.ts'
 import type { XSchema } from '../types/schema.ts'
 import type { XType } from '../types/type.ts'
 import type { XUnevaluatedProperties } from '../types/unevaluatedProperties.ts'
-
 import type { XStaticAdditionalProperties } from './additionalProperties.ts'
 import type { XStaticAllOf } from './allOf.ts'
 import type { XStaticAnyOf } from './anyOf.ts'
@@ -69,13 +68,13 @@ type XFromKeywords<Stack extends string[], Root extends XSchema, Schema extends
   Schema extends XAllOf<infer Types extends XSchema[]> ? XStaticAllOf<Stack, Root, Types> : unknown,
   Schema extends XAnyOf<infer Types extends XSchema[]> ? XStaticAnyOf<Stack, Root, Types> : unknown,
   Schema extends XConst<infer Value extends unknown> ? XStaticConst<Value> : unknown,
-  Schema extends XIf<infer Type extends XSchema> ? XStaticIf<Stack, Root, Schema, Type> :
+  Schema extends XIf<infer Type extends XSchema> ? XStaticIf<Stack, Root, Schema, Type> : unknown,
   Schema extends XEnum<infer Values extends unknown[]> ? XStaticEnum<Values> : unknown,
   Schema extends XItems<infer Types extends XSchema[] | XSchema> ? XStaticItems<Stack, Root, Schema, Types> : unknown,
   Schema extends XOneOf<infer Types extends XSchema[]> ? XStaticOneOf<Stack, Root, Types> : unknown,
   Schema extends XPatternProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticPatternProperties<Stack, Root, Properties> : unknown,
   Schema extends XPrefixItems<infer Types extends XSchema[]> ? XStaticPrefixItems<Stack, Root, Schema, Types> : unknown,
-  Schema extends XProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticProperties<Stack, Root, Properties> : unknown,
+  Schema extends XProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticProperties<Stack, Root, Schema, Properties> : unknown,
   Schema extends XRef<infer Ref extends string> ? XStaticRef<Stack, Root, Ref> : unknown,
   Schema extends XRequired<infer Keys extends string[]> ? XStaticRequired<Stack, Root, Schema, Keys> : unknown,
   Schema extends XType<infer TypeName extends string[] | string> ? XStaticType<TypeName> : unknown,

src/schema/static/static.ts

@@ -30,14 +30,14 @@ THE SOFTWARE.
 // deno-fmt-ignore-file
 
 import type { XSchema } from '../types/schema.ts'
-import type { XNonReadonly } from './~non-readonly.ts'
+import type { XCanonical } from './~canonical.ts'
 import type { XStaticSchema } from './schema.ts'
 
 // ------------------------------------------------------------------
 // XStatic
 // ------------------------------------------------------------------
 export type XStatic<Value extends unknown,
   Schema extends XSchema = Value extends XSchema ? Value : {},
-  NonReadonly extends XSchema = XNonReadonly<Schema>,
-  Result extends unknown = XStaticSchema<[], NonReadonly, NonReadonly>  
+  Canonical extends XSchema = XCanonical<Schema>,
+  Result extends unknown = XStaticSchema<[], Canonical, Canonical>  
 > = Result

src/schema/static/~non-readonly.ts src/schema/static/~canonical.tssrc/schema/static/~non-readonly.ts renamed to src/schema/static/~canonical.ts

@@ -29,31 +29,32 @@ THE SOFTWARE.
 // deno-fmt-ignore-file
 
 // ------------------------------------------------------------------
-// Tuple
+// CanonicalTuple
 // ------------------------------------------------------------------
-type XFromTuple<Value extends readonly unknown[]> = (
+type XCanonicalTuple<Value extends readonly unknown[]> = (
   Value extends [infer Left, ...infer Right extends unknown[]] 
-    ? [XNonReadonly<Left>, ...XFromTuple<Right>]
+    ? [XCanonical<Left>, ...XCanonicalTuple<Right>]
     : []
 )
 // ------------------------------------------------------------------
-// Array
+// CanonicalArray
 // ------------------------------------------------------------------
-type XFromArray<Value extends unknown, 
-  Result extends unknown[] = XNonReadonly<Value>[]
+type XCanonicalArray<Value extends unknown, 
+  Result extends unknown[] = XCanonical<Value>[]
 > = Result
 // ------------------------------------------------------------------
-// Object
+// CanonicalObject
 // ------------------------------------------------------------------
-type XFromObject< Value extends object, Result extends Record<PropertyKey, unknown> = {
-  -readonly [K in keyof Value]: XNonReadonly<Value[K]>
+type XCanonicalObject< Value extends object, Result extends Record<PropertyKey, unknown> = {
+  -readonly [Key in keyof Value]: XCanonical<Value[Key]>
 }> = Result
+
 // ------------------------------------------------------------------
-// Mutable
+// Canonical (i.e. Non-Readonly)
 // ------------------------------------------------------------------
-export type XNonReadonly<Value extends unknown> = (
-  Value extends readonly [...infer Schemas extends unknown[]] ? XFromTuple<Schemas> : 
-  Value extends readonly (infer Schema)[] ? XFromArray<Schema> : 
-  Value extends object ? XFromObject<Value> : 
-  Value
+export type XCanonical<Schema extends unknown> = (
+  Schema extends readonly [...infer Schemas extends unknown[]] ? XCanonicalTuple<Schemas> : 
+  Schema extends readonly (infer Schema)[] ? XCanonicalArray<Schema> : 
+  Schema extends object ? XCanonicalObject<Schema> : 
+  Schema
 )

src/schema/static/~readonly.ts

@@ -9,7 +9,7 @@ import { Metrics } from './task/metrics/index.ts'
 import { Spec } from './task/spec/index.ts'
 import { Task } from 'tasksmith'
 
-const Version = '1.1.26'
+const Version = '1.1.27'
 
 // ------------------------------------------------------------------
 // Build