typebox 1.1.19 → 1.1.21

package/build/value/create/from-literal.mjs

@@ -1,4 +1,4 @@
 // deno-fmt-ignore-file
-export function FromLiteral(context, type) {
+export function FromLiteral(_context, type) {
     return type.const;
 }

package/build/value/create/from-never.d.mts

@@ -1,2 +1,2 @@
 import type { TProperties, TNever } from '../../type/index.mjs';
-export declare function FromNever(context: TProperties, type: TNever): unknown;
+export declare function FromNever(_context: TProperties, type: TNever): unknown;

package/build/value/create/from-never.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
 import { CreateError } from './error.mjs';
-export function FromNever(context, type) {
+export function FromNever(_context, type) {
     throw new CreateError(type, 'Cannot create TNever types');
 }

package/build/value/create/from-null.d.mts

@@ -1,2 +1,2 @@
 import type { TProperties, TNull } from '../../type/index.mjs';
-export declare function FromNull(context: TProperties, type: TNull): unknown;
+export declare function FromNull(_context: TProperties, _type: TNull): unknown;

package/build/value/create/from-null.mjs

@@ -1,4 +1,4 @@
 // deno-fmt-ignore-file
-export function FromNull(context, type) {
+export function FromNull(_context, _type) {
     return null;
 }

package/build/value/create/from-number.d.mts

@@ -1,2 +1,2 @@
 import type { TProperties, TNumber } from '../../type/index.mjs';
-export declare function FromNumber(context: TProperties, type: TNumber): unknown;
+export declare function FromNumber(_context: TProperties, type: TNumber): unknown;

package/build/value/create/from-number.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 import { IsExclusiveMinimum, IsMinimum } from '../../schema/types/index.mjs';
-export function FromNumber(context, type) {
+export function FromNumber(_context, type) {
     return (IsExclusiveMinimum(type) && Guard.IsNumber(type.exclusiveMinimum) ? type.exclusiveMinimum + 1 :
         IsMinimum(type) ? type.minimum :
             0);

package/build/value/create/from-record.d.mts

@@ -1,2 +1,2 @@
 import type { TProperties, TRecord } from '../../type/index.mjs';
-export declare function FromRecord(context: TProperties, type: TRecord): unknown;
+export declare function FromRecord(_context: TProperties, type: TRecord): unknown;

package/build/value/create/from-record.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { IsMinProperties, IsDefault } from '../../schema/types/index.mjs';
 import { CreateError } from './error.mjs';
-export function FromRecord(context, type) {
+export function FromRecord(_context, type) {
     if (IsMinProperties(type) && !IsDefault(type))
         throw new CreateError(type, 'Record with the minProperties constraint must have a default annotation');
     return {};

package/build/value/create/from-string.d.mts

@@ -1,2 +1,2 @@
 import type { TProperties, TString } from '../../type/index.mjs';
-export declare function FromString(context: TProperties, type: TString): unknown;
+export declare function FromString(_context: TProperties, type: TString): unknown;

package/build/value/create/from-string.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { IsPattern, IsFormat, IsDefault, IsMinLength } from '../../schema/types/index.mjs';
-export function FromString(context, type) {
+export function FromString(_context, type) {
     const needsDefault = (IsPattern(type) || IsFormat(type)) && !IsDefault(type);
     if (needsDefault)
         throw Error('Strings with format or pattern constraints must specify default');

package/build/value/create/from-symbol.d.mts

@@ -1,2 +1,2 @@
 import type { TProperties, TSymbol } from '../../type/index.mjs';
-export declare function FromSymbol(context: TProperties, type: TSymbol): unknown;
+export declare function FromSymbol(_context: TProperties, _type: TSymbol): unknown;

package/build/value/create/from-symbol.mjs

@@ -1,4 +1,4 @@
 // deno-fmt-ignore-file
-export function FromSymbol(context, type) {
+export function FromSymbol(_context, _type) {
     return Symbol();
 }

package/build/value/create/from-undefined.d.mts

@@ -1,2 +1,2 @@
 import type { TProperties, TUndefined } from '../../type/index.mjs';
-export declare function FromUndefined(context: TProperties, type: TUndefined): unknown;
+export declare function FromUndefined(_context: TProperties, _type: TUndefined): unknown;

package/build/value/create/from-undefined.mjs

@@ -1,4 +1,4 @@
 // deno-fmt-ignore-file
-export function FromUndefined(context, type) {
+export function FromUndefined(_context, _type) {
     return undefined;
 }

package/build/value/create/from-void.d.mts

@@ -1,2 +1,2 @@
 import type { TProperties, TVoid } from '../../type/index.mjs';
-export declare function FromVoid(context: TProperties, type: TVoid): unknown;
+export declare function FromVoid(_context: TProperties, _type: TVoid): unknown;

package/build/value/create/from-void.mjs

@@ -1,4 +1,4 @@
 // deno-fmt-ignore-file
-export function FromVoid(context, type) {
+export function FromVoid(_context, _type) {
     return void 0;
 }

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.19",
+  "version": "1.1.21",
   "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"
       ]

package/build/system/environment/can-evaluate.d.mts

@@ -1,2 +0,0 @@
-/** Returns true if the environment supports dynamic JavaScript evaluation */
-export declare function CanAccelerate(): boolean;

package/build/system/environment/can-evaluate.mjs

@@ -1,26 +0,0 @@
-import { Settings } from '../settings/index.mjs';
-import { Guard } from '../../guard/index.mjs';
-let supported = undefined;
-// ------------------------------------------------------------------
-// TryEval
-// ------------------------------------------------------------------
-// deno-coverage-ignore-start - catch is environment dependent
-function TryEval() {
-    try {
-        new globalThis.Function('null')();
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// deno-coverage-ignore-stop
-// ------------------------------------------------------------------
-// CanEvaluate
-// ------------------------------------------------------------------
-/** Returns true if the environment supports dynamic JavaScript evaluation */
-export function CanAccelerate() {
-    if (Guard.IsUndefined(supported))
-        supported = TryEval();
-    return supported && Settings.Get().useAcceleration;
-}