typebox 1.1.18 → 1.1.20

package/build/value/clean/from-union.mjs

@@ -2,8 +2,9 @@
 import { Check } from '../check/index.mjs';
 import { Clone } from '../clone/index.mjs';
 import { FromType } from './from-type.mjs';
+import { UnionPrioritySort } from '../shared/union-priority-sort.mjs';
 export function FromUnion(context, type, value) {
-    for (const schema of type.anyOf) {
+    for (const schema of UnionPrioritySort(type.anyOf)) {
         const clean = FromType(context, schema, Clone(value));
         if (Check(context, schema, clean))
             return clean;

package/build/value/codec/from-intersect.mjs

@@ -2,27 +2,57 @@
 import { Guard } from '../../guard/index.mjs';
 import { FromType } from './from-type.mjs';
 import { Callback } from './callback.mjs';
+import { Clone } from '../clone/index.mjs';
+import { Clean } from '../clean/index.mjs';
+// ------------------------------------------------------------------
+// MergeInteriors
+//
+// Merges all interior operand results into a single object. Each
+// subsequent operand's properties override those of prior operands.
+//
+// ------------------------------------------------------------------
+function MergeInteriors(interiors) {
+    return interiors.reduce((results, interior) => ({ ...results, ...interior }), {});
+}
+// ------------------------------------------------------------------
+// NonMatchingInterior
+//
+// Used when Intersect operands do not all produce Objects. Returns
+// the first interior result that differs from the original value,
+// indicating a Codec has transformed the data. If no operand
+// produced a change, defaults to the first interior result.
+//
+// ------------------------------------------------------------------
+function NonMatchingInterior(value, interiors) {
+    for (const interior of interiors)
+        if (!Guard.IsDeepEqual(value, interior))
+            return interior;
+    return value; // value-unchanged
+}
 // ------------------------------------------------------------------
 // Decode
 // ------------------------------------------------------------------
 function Decode(direction, context, type, value) {
-    for (const schema of type.allOf) {
-        value = FromType(direction, context, schema, value);
-    }
-    return Callback(direction, context, type, value);
+    if (Guard.IsEqual(type.allOf.length, 0))
+        return Callback(direction, context, type, value);
+    const interiors = type.allOf.map((schema) => FromType(direction, context, schema, Clean(schema, Clone(value))));
+    const structural = interiors.every((result) => Guard.IsObject(result));
+    const exterior = structural ? MergeInteriors(interiors) : NonMatchingInterior(value, interiors);
+    return Callback(direction, context, type, exterior);
 }
 // ------------------------------------------------------------------
 // Encode
 // ------------------------------------------------------------------
 function Encode(direction, context, type, value) {
-    let exterior = Callback(direction, context, type, value);
-    for (const schema of type.allOf) {
-        exterior = FromType(direction, context, schema, exterior);
-    }
-    return exterior;
+    if (Guard.IsEqual(type.allOf.length, 0))
+        return Callback(direction, context, type, value);
+    const exterior = Callback(direction, context, type, value);
+    const interiors = type.allOf.map((schema) => FromType(direction, context, schema, Clean(schema, Clone(exterior))));
+    const structural = interiors.every((result) => Guard.IsObject(result));
+    if (structural)
+        return MergeInteriors(interiors);
+    return NonMatchingInterior(exterior, interiors);
 }
 export function FromIntersect(direction, context, type, value) {
-    return Guard.IsEqual(direction, 'Decode')
-        ? Decode(direction, context, type, value)
-        : Encode(direction, context, type, value);
+    return Guard.IsEqual(direction, 'Decode') ? Decode(direction, context, type, value) : Encode(direction, context, type, value);
 }

package/build/value/codec/from-object.mjs

@@ -3,7 +3,7 @@ import { Unreachable } from '../../system/unreachable/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { FromType } from './from-type.mjs';
 import { Callback } from './callback.mjs';
-import { IsOptionalUndefined } from '../shared/index.mjs';
+import { IsOptionalUndefined } from '../shared/optional-undefined.mjs';
 // ------------------------------------------------------------------
 // Decode
 // ------------------------------------------------------------------

package/build/value/codec/from-union.mjs

@@ -1,30 +1,28 @@
 // deno-fmt-ignore-file
-import { Unreachable } from '../../system/unreachable/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { Callback } from './callback.mjs';
 import { FromType } from './from-type.mjs';
 import { Clone } from '../clone/index.mjs';
 import { Check } from '../check/index.mjs';
+import { UnionPrioritySort } from '../shared/union-priority-sort.mjs';
 // ------------------------------------------------------------------
 // Decode
 // ------------------------------------------------------------------
-// deno-coverage-ignore-start - unreachable | checked
 function Decode(direction, context, type, value) {
-    for (const schema of type.anyOf) {
+    for (const schema of UnionPrioritySort(type.anyOf, 1)) {
         if (!Check(context, schema, value))
             continue;
         const variant = FromType(direction, context, schema, value);
         return Callback(direction, context, type, variant);
     }
-    return Unreachable();
+    return value;
 }
-// deno-coverage-ignore-stop
 // ------------------------------------------------------------------
 // Encode
 // ------------------------------------------------------------------
 function Encode(direction, context, type, value) {
     let exterior = Callback(direction, context, type, value);
-    for (const schema of type.anyOf) {
+    for (const schema of UnionPrioritySort(type.anyOf, -1)) {
         const variant = FromType(direction, context, schema, Clone(exterior));
         if (!Check(context, schema, variant))
             continue;

package/build/value/convert/from-object.mjs

@@ -2,7 +2,7 @@
 import { Guard } from '../../guard/index.mjs';
 import { FromType } from './from-type.mjs';
 import { FromAdditionalProperties } from './from-additional.mjs';
-import { IsOptionalUndefined } from '../shared/index.mjs';
+import { IsOptionalUndefined } from '../shared/optional-undefined.mjs';
 // ------------------------------------------------------------------
 // FromProperties
 // ------------------------------------------------------------------

package/build/value/index.d.mts

@@ -15,6 +15,7 @@ export * from './delta/index.mjs';
 export * from './pipeline/index.mjs';
 export * from './pointer/index.mjs';
 export * from './repair/index.mjs';
+export * from './shared/index.mjs';
 import * as Value from './value.mjs';
 export * as Value from './value.mjs';
 export default Value;

package/build/value/index.mjs

@@ -19,6 +19,10 @@ export * from './pipeline/index.mjs';
 export * from './pointer/index.mjs';
 export * from './repair/index.mjs';
 // ------------------------------------------------------------------
+// Shared
+// ------------------------------------------------------------------
+export * from './shared/index.mjs';
+// ------------------------------------------------------------------
 // Default
 // ------------------------------------------------------------------
 import * as Value from './value.mjs';

package/build/value/repair/from-union.mjs

@@ -1,65 +1,18 @@
 // deno-fmt-ignore-file
 import { IsDefault } from '../../schema/types/index.mjs';
-import { Union, IsLiteral, IsObject, IsRef } from '../../type/index.mjs';
+import { Union } from '../../type/index.mjs';
 import { Flatten } from '../../type/engine/evaluate/index.mjs';
-import { Guard } from '../../guard/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Clone } from '../clone/index.mjs';
 import { Create } from '../create/index.mjs';
-import { RepairError } from './error.mjs';
 import { FromType } from './from-type.mjs';
-// ------------------------------------------------------------------
-// Deref
-// ------------------------------------------------------------------
-function Deref(context, type, value) {
-    return IsRef(type)
-        ? Guard.HasPropertyKey(context, type.$ref)
-            ? Deref(context, context[type.$ref], value)
-            : (() => { throw new RepairError(context, type, value, 'Unable to Deref target on Union repair'); })()
-        : type;
-}
-// ------------------------------------------------------------------
-// The following will score a schema against a value. For objects,
-// the score is the tally of points awarded for each property of
-// the value. Property points are (1.0 / propertyCount) to prevent
-// large property counts biasing results. Properties that match
-// literal values are maximally awarded as literals are typically
-// used as union discriminator fields.
-// ------------------------------------------------------------------
-function ScoreVariant(context, type, value) {
-    // scoring is only possible for object types.
-    if (!(IsObject(type) && Guard.IsObject(value)))
-        return 0;
-    const keys = Guard.Keys(value);
-    const entries = Guard.Entries(type.properties);
-    return entries.reduce((result, [key, schema]) => {
-        const literal = IsLiteral(schema) && Guard.IsEqual(schema.const, value[key]) ? 100 : 0;
-        const checks = Check(context, schema, value[key]) ? 10 : 0;
-        const exists = keys.includes(key) ? 1 : 0;
-        return result + (literal + checks + exists);
-    }, 0);
-}
-// ------------------------------------------------------------------
-// SelectVariant
-// ------------------------------------------------------------------
-function SelectVariant(context, type, value) {
-    const schemas = type.anyOf.map((schema) => Deref(context, schema, value));
-    let [select, best] = [schemas[0], 0];
-    for (const schema of schemas) {
-        const score = ScoreVariant(context, schema, value);
-        if (score > best) {
-            select = schema;
-            best = score;
-        }
-    }
-    return select;
-}
+import { UnionScoreSelect } from '../shared/union-score-select.mjs';
 // ------------------------------------------------------------------
 // RepairUnion
 // ------------------------------------------------------------------
 function RepairUnion(context, type, value) {
     const union = Union(Flatten(type.anyOf));
-    const schema = SelectVariant(context, union, value);
+    const schema = UnionScoreSelect(context, union, value);
     return FromType(context, schema, value);
 }
 export function FromUnion(context, type, value) {

package/build/value/shared/index.d.mts

@@ -1 +1,3 @@
 export * from './optional-undefined.mjs';
+export * from './union-priority-sort.mjs';
+export * from './union-score-select.mjs';

package/build/value/shared/index.mjs

@@ -1,2 +1,4 @@
 // deno-fmt-ignore-file
 export * from './optional-undefined.mjs';
+export * from './union-priority-sort.mjs';
+export * from './union-score-select.mjs';

package/build/value/shared/union-priority-sort.d.mts

@@ -0,0 +1,3 @@
+import { type TSchema } from '../../type/index.mjs';
+/** Deterministically sorts schemas by structural relationship (narrow to broad) */
+export declare function UnionPrioritySort(types: TSchema[], order?: number): TSchema[];

package/build/value/shared/union-priority-sort.mjs

@@ -0,0 +1,36 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Compare } from '../../type/index.mjs';
+// ------------------------------------------------------------------
+// DeterministicCompare
+//
+// Provides a deterministic tie-break for schemas. This is used when
+// schemas are structurally disjoint or mutually inclusive. While
+// JSON serialization incurs a performance overhead, it serves as a
+// reliable mechanism to ensure stable ordering and preserves the
+// alphabetical alignment of named constants.
+//
+// ------------------------------------------------------------------
+function DeterministicCompare(left, right) {
+    return JSON.stringify(left).localeCompare(JSON.stringify(right));
+}
+// ------------------------------------------------------------------
+// UnionPrioritySort
+//
+// Performs a deterministic sort on Union members. By default, this
+// function ensures that narrow (more specific) types precede broader
+// types in the resulting array. The order can be reversed by setting
+// the order property to -1 which will reverse unions from broader
+// to more narrow.
+//
+// ------------------------------------------------------------------
+/** Deterministically sorts schemas by structural relationship (narrow to broad) */
+export function UnionPrioritySort(types, order = 1) {
+    return types.sort((left, right) => {
+        const result = Compare(left, right);
+        return (Guard.IsEqual(result, 'disjoint') ? DeterministicCompare(left, right) :
+            Guard.IsEqual(result, 'right-inside') ? 1 :
+                Guard.IsEqual(result, 'left-inside') ? -1 :
+                    DeterministicCompare(left, right)) * order;
+    });
+}

package/build/value/shared/union-score-select.d.mts

@@ -0,0 +1,3 @@
+import { type TProperties, type TSchema, type TUnion } from '../../type/index.mjs';
+/** Scores Union variants and returns the best match for the given value */
+export declare function UnionScoreSelect(context: TProperties, type: TUnion, value: unknown): TSchema;

package/build/value/shared/union-score-select.mjs

@@ -0,0 +1,51 @@
+// deno-fmt-ignore-file
+import { IsLiteral, IsObject, IsRef } from '../../type/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { Check } from '../check/index.mjs';
+// ------------------------------------------------------------------
+// Deref
+// ------------------------------------------------------------------
+function Deref(context, type, value) {
+    return IsRef(type)
+        ? Guard.HasPropertyKey(context, type.$ref)
+            ? Deref(context, context[type.$ref], value)
+            : (() => { throw new Error('Unable to Deref target'); })()
+        : type;
+}
+// ------------------------------------------------------------------
+// The following will score a schema against a value. For objects,
+// the score is the tally of points awarded for each property of
+// the value. Property points are (1.0 / propertyCount) to prevent
+// large property counts biasing results. Properties that match
+// literal values are maximally awarded as literals are typically
+// used as union discriminator fields.
+// ------------------------------------------------------------------
+function ScoreVariant(context, type, value) {
+    // scoring is only possible for object types.
+    if (!(IsObject(type) && Guard.IsObject(value)))
+        return 0;
+    const keys = Guard.Keys(value);
+    const entries = Guard.Entries(type.properties);
+    return entries.reduce((result, [key, schema]) => {
+        const literal = IsLiteral(schema) && Guard.IsEqual(schema.const, value[key]) ? 100 : 0;
+        const checks = Check(context, schema, value[key]) ? 10 : 0;
+        const exists = keys.includes(key) ? 1 : 0;
+        return result + (literal + checks + exists);
+    }, 0);
+}
+// ------------------------------------------------------------------
+// UnionScoreSelect
+// ------------------------------------------------------------------
+/** Scores Union variants and returns the best match for the given value */
+export function UnionScoreSelect(context, type, value) {
+    const schemas = type.anyOf.map((schema) => Deref(context, schema, value));
+    let [select, best] = [schemas[0], 0];
+    for (const schema of schemas) {
+        const score = ScoreVariant(context, schema, value);
+        if (score > best) {
+            select = schema;
+            best = score;
+        }
+    }
+    return select;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.1.18",
+  "version": "1.1.20",
   "keywords": [
     "typescript",
     "jsonschema"
@@ -16,29 +16,21 @@
   "types": "./build/index.d.mts",
   "module": "./build/index.mjs",
   "exports": {
-    "./system": {
-      "import": "./build/system/index.mjs",
-      "default": "./build/system/index.mjs"
-    },
-    "./compile": {
-      "import": "./build/compile/index.mjs",
-      "default": "./build/compile/index.mjs"
-    },
-    "./value": {
-      "import": "./build/value/index.mjs",
-      "default": "./build/value/index.mjs"
+    "./guard": {
+      "import": "./build/guard/index.mjs",
+      "default": "./build/guard/index.mjs"
     },
     "./error": {
       "import": "./build/error/index.mjs",
       "default": "./build/error/index.mjs"
     },
-    "./guard": {
-      "import": "./build/guard/index.mjs",
-      "default": "./build/guard/index.mjs"
+    "./compile": {
+      "import": "./build/compile/index.mjs",
+      "default": "./build/compile/index.mjs"
     },
-    "./schema": {
-      "import": "./build/schema/index.mjs",
-      "default": "./build/schema/index.mjs"
+    "./system": {
+      "import": "./build/system/index.mjs",
+      "default": "./build/system/index.mjs"
     },
     "./format": {
       "import": "./build/format/index.mjs",
@@ -48,6 +40,14 @@
       "import": "./build/type/index.mjs",
       "default": "./build/type/index.mjs"
     },
+    "./schema": {
+      "import": "./build/schema/index.mjs",
+      "default": "./build/schema/index.mjs"
+    },
+    "./value": {
+      "import": "./build/value/index.mjs",
+      "default": "./build/value/index.mjs"
+    },
     ".": {
       "import": "./build/index.mjs",
       "default": "./build/index.mjs"
@@ -55,23 +55,17 @@
   },
   "typesVersions": {
     "*": {
-      "system": [
-        "./build/system/index.d.mts"
-      ],
-      "compile": [
-        "./build/compile/index.d.mts"
-      ],
-      "value": [
-        "./build/value/index.d.mts"
+      "guard": [
+        "./build/guard/index.d.mts"
       ],
       "error": [
         "./build/error/index.d.mts"
       ],
-      "guard": [
-        "./build/guard/index.d.mts"
+      "compile": [
+        "./build/compile/index.d.mts"
       ],
-      "schema": [
-        "./build/schema/index.d.mts"
+      "system": [
+        "./build/system/index.d.mts"
       ],
       "format": [
         "./build/format/index.d.mts"
@@ -79,6 +73,12 @@
       "type": [
         "./build/type/index.d.mts"
       ],
+      "schema": [
+        "./build/schema/index.d.mts"
+      ],
+      "value": [
+        "./build/value/index.d.mts"
+      ],
       ".": [
         "./build/index.d.mts"
       ]