typebox 0.0.1 → 1.0.0

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

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { Evaluate } from '../../type/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromIntersect(context, type, value) {
+    const evaluated = Evaluate(type);
+    return FromType(context, evaluated, value);
+}

package/build/value/repair/from-object.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TObject } from '../../type/index.mjs';
+export declare function FromObject(context: TProperties, type: TObject, value: unknown): unknown;

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

@@ -0,0 +1,33 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Check } from '../check/index.mjs';
+import { Create } from '../create/index.mjs';
+import { IsAdditionalProperties } from '../../schema/types/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromObject(context, type, value) {
+    if (Check(context, type, value))
+        return value;
+    if (!Guard.IsObjectNotArray(value))
+        return Create(context, type);
+    // Dependencies
+    const required = new Set(Guard.IsUndefined(type.required) ? [] : type.required);
+    // Properties
+    const result = {};
+    for (const [key, schema] of Guard.Entries(type.properties)) {
+        if (!required.has(key) && Guard.IsUndefined(value[key]))
+            continue;
+        result[key] = key in value
+            ? FromType(context, schema, value[key])
+            : Create(context, schema);
+    }
+    // AdditionalProperties
+    const evaluatedKeys = Guard.Keys(type.properties);
+    if (IsAdditionalProperties(type) && Guard.IsObject(type.additionalProperties)) {
+        for (const key of Guard.Keys(value)) {
+            if (evaluatedKeys.includes(key))
+                continue;
+            result[key] = FromType(context, type.additionalProperties, value[key]);
+        }
+    }
+    return result;
+}

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

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

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

@@ -0,0 +1,33 @@
+// deno-fmt-ignore-file
+import { IsAdditionalProperties } from '../../schema/types/index.mjs';
+import { RecordValue, RecordPattern } from '../../type/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { Create } from '../create/index.mjs';
+import { Check } from '../check/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromRecord(context, type, value) {
+    if (Check(context, type, value))
+        return value;
+    if (Guard.IsNull(value) || !Guard.IsObject(value) || Guard.IsArray(value))
+        return Create(context, type);
+    const recordKey = new RegExp(RecordPattern(type));
+    const recordValue = RecordValue(type);
+    const evaluatedKeys = new Set();
+    // PatternProperties
+    const result = {};
+    for (const [key, value_] of Guard.Entries(value)) {
+        if (!recordKey.test(key))
+            continue;
+        result[key] = FromType(context, recordValue, value_);
+        evaluatedKeys.add(key);
+    }
+    // AdditionalProperties
+    if (IsAdditionalProperties(type)) {
+        for (const key of Guard.Keys(value)) {
+            if (evaluatedKeys.has(key))
+                continue;
+            result[key] = FromType(context, type.additionalProperties, value[key]);
+        }
+    }
+    return result;
+}

package/build/value/repair/from-ref.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TRef } from '../../type/index.mjs';
+export declare function FromRef(context: TProperties, type: TRef, value: unknown): unknown;

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

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+import { RepairError } from './error.mjs';
+export function FromRef(context, type, value) {
+    return Guard.HasPropertyKey(context, type.$ref)
+        ? FromType(context, context[type.$ref], value)
+        : (() => { throw new RepairError(context, type, value, 'Unable to de-reference target type'); })();
+}

package/build/value/repair/from-template-literal.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TTemplateLiteral } from '../../type/index.mjs';
+export declare function FromTemplateLiteral(context: TProperties, type: TTemplateLiteral, value: unknown): unknown;

package/build/value/repair/from-template-literal.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { TemplateLiteralDecode } from '../../type/engine/template-literal/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromTemplateLiteral(context, type, value) {
+    const decoded = TemplateLiteralDecode(type.pattern);
+    return FromType(context, decoded, value);
+}

package/build/value/repair/from-tuple.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TTuple } from '../../type/index.mjs';
+export declare function FromTuple(context: TProperties, schema: TTuple, value: unknown): unknown;

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

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Check } from '../check/index.mjs';
+import { Create } from '../create/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromTuple(context, schema, value) {
+    if (Check(context, schema, value))
+        return value;
+    if (!Guard.IsArray(value))
+        return Create(context, schema);
+    return schema.items.map((schema, index) => FromType(context, schema, value[index]));
+}

package/build/value/repair/from-type.d.mts

@@ -0,0 +1,2 @@
+import * as T from '../../type/index.mjs';
+export declare function FromType(context: T.TProperties, type: T.TSchema, value: unknown): unknown;

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

@@ -0,0 +1,59 @@
+// deno-fmt-ignore-file
+import { Guard, GlobalsGuard } from '../../guard/index.mjs';
+import * as T from '../../type/index.mjs';
+import { FromArray } from './from-array.mjs';
+import { FromEnum } from './from-enum.mjs';
+import { FromIntersect } from './from-intersect.mjs';
+import { FromObject } from './from-object.mjs';
+import { FromRecord } from './from-record.mjs';
+import { FromRef } from './from-ref.mjs';
+import { FromTemplateLiteral } from './from-template-literal.mjs';
+import { FromTuple } from './from-tuple.mjs';
+import { FromUnion } from './from-union.mjs';
+import { FromUnknown } from './from-unknown.mjs';
+import { RepairError } from './error.mjs';
+// ------------------------------------------------------------------
+// AssertRepairableValue
+// ------------------------------------------------------------------
+function AssertRepairableValue(context, type, value) {
+    const unsupported = GlobalsGuard.IsDate(value)
+        || GlobalsGuard.IsMap(value)
+        || GlobalsGuard.IsSet(value)
+        || GlobalsGuard.IsTypeArray(value)
+        || Guard.IsConstructor(value)
+        || Guard.IsFunction(value);
+    if (unsupported) {
+        throw new RepairError(context, type, value, 'Value is not repairable');
+    }
+}
+// ------------------------------------------------------------------
+// AssertRepairableType
+// ------------------------------------------------------------------
+function AssertRepairableType(context, type, value) {
+    const unsupported = T.IsAsyncIterator(type)
+        || T.IsIterator(type)
+        || T.IsConstructor(type)
+        || T.IsFunction(type)
+        || T.IsNever(type)
+        || T.IsPromise(type);
+    if (unsupported) {
+        throw new RepairError(context, type, value, 'Type is not repairable');
+    }
+}
+// ------------------------------------------------------------------
+// FromType
+// ------------------------------------------------------------------
+export function FromType(context, type, value) {
+    AssertRepairableValue(context, type, value);
+    AssertRepairableType(context, type, value);
+    return (T.IsArray(type) ? FromArray(context, type, value) :
+        T.IsEnum(type) ? FromEnum(context, type, value) :
+            T.IsIntersect(type) ? FromIntersect(context, type, value) :
+                T.IsObject(type) ? FromObject(context, type, value) :
+                    T.IsRecord(type) ? FromRecord(context, type, value) :
+                        T.IsRef(type) ? FromRef(context, type, value) :
+                            T.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type, value) :
+                                T.IsTuple(type) ? FromTuple(context, type, value) :
+                                    T.IsUnion(type) ? FromUnion(context, type, value) :
+                                        FromUnknown(context, type, value));
+}

package/build/value/repair/from-union.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, type TUnion } from '../../type/index.mjs';
+export declare function FromUnion(context: TProperties, type: TUnion, value: unknown): unknown;

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

@@ -0,0 +1,71 @@
+// deno-fmt-ignore-file
+import { IsDefault } from '../../schema/types/index.mjs';
+import { Union, IsLiteral, IsObject, IsRef } 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;
+}
+// ------------------------------------------------------------------
+// RepairUnion
+// ------------------------------------------------------------------
+function RepairUnion(context, type, value) {
+    const union = Union(Flatten(type.anyOf));
+    const schema = SelectVariant(context, union, value);
+    return FromType(context, schema, value);
+}
+export function FromUnion(context, type, value) {
+    if (Check(context, type, value))
+        return Clone(value);
+    if (IsDefault(type))
+        return Create(context, type);
+    return RepairUnion(context, type, value);
+}

package/build/value/repair/from-unknown.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TSchema } from '../../type/index.mjs';
+export declare function FromUnknown(context: TProperties, type: TSchema, value: unknown): unknown;

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

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Check } from '../check/index.mjs';
+import { Create } from '../create/index.mjs';
+import { Convert } from '../convert/index.mjs';
+export function FromUnknown(context, type, value) {
+    if (Check(context, type, value))
+        return value;
+    const converted = Convert(context, type, value);
+    if (Check(context, type, converted))
+        return converted;
+    return Create(context, type);
+}

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

@@ -0,0 +1 @@
+export * from './repair.mjs';

package/build/value/repair/index.mjs

@@ -0,0 +1 @@
+export * from './repair.mjs';

package/build/value/repair/repair.d.mts

@@ -0,0 +1,17 @@
+import type { TProperties, TSchema, Static } from '../../type/index.mjs';
+/**
+ * Repairs a value to match the provided type. This function is intended for data migration
+ * scenarios where existing values need to be migrating to an updated type. This function will
+ * repair partially mismatched values by populating missing sub-properties and elements with
+ * default structures derived from the type. If the value already conforms to the type, no
+ * action is performed.
+ */
+export declare function Repair<const Type extends TSchema, Result extends unknown = Static<Type>>(type: Type, value: unknown): Result;
+/**
+ * Repairs a value to match the provided type. This function is intended for data migration
+ * scenarios where existing values need to be migrating to an updated type. This function will
+ * repair partially mismatched values by populating missing sub-properties and elements with
+ * default structures derived from the type. If the value already conforms to the type, no
+ * action is performed.
+ */
+export declare function Repair<Context extends TProperties, const Type extends TSchema, Result extends unknown = Static<Type, Context>>(context: Context, type: Type, value: unknown): Result;

package/build/value/repair/repair.mjs

@@ -0,0 +1,20 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+import { FromType } from './from-type.mjs';
+import { Assert } from '../assert/index.mjs';
+/**
+ * Repairs a value to match the provided type. This function is intended for data migration
+ * scenarios where existing values need to be migrating to an updated type. This function will
+ * repair partially mismatched values by populating missing sub-properties and elements with
+ * default structures derived from the type. If the value already conforms to the type, no
+ * action is performed.
+ */
+export function Repair(...args) {
+    const [context, type, value] = Arguments.Match(args, {
+        3: (context, type, value) => [context, type, value],
+        2: (type, value) => [{}, type, value],
+    });
+    const result = FromType(context, type, value);
+    Assert(context, type, result); // ensure correct
+    return result;
+}

package/build/value/value.d.mts

@@ -0,0 +1,16 @@
+export { Assert } from './assert/index.mjs';
+export { Check } from './check/index.mjs';
+export { Clean } from './clean/index.mjs';
+export { Clone } from './clone/index.mjs';
+export { Decode, Encode, HasCodec } from './codec/index.mjs';
+export { Convert } from './convert/index.mjs';
+export { Create } from './create/index.mjs';
+export { Default } from './default/index.mjs';
+export { Equal } from './equal/index.mjs';
+export { Errors } from './errors/index.mjs';
+export { Hash } from './hash/index.mjs';
+export { Mutate, type TMutable } from './mutate/index.mjs';
+export { Parse } from './parse/index.mjs';
+export { Diff, Patch } from './delta/index.mjs';
+export { Pointer } from './pointer/index.mjs';
+export { Repair } from './repair/index.mjs';

package/build/value/value.mjs

@@ -0,0 +1,16 @@
+export { Assert } from './assert/index.mjs';
+export { Check } from './check/index.mjs';
+export { Clean } from './clean/index.mjs';
+export { Clone } from './clone/index.mjs';
+export { Decode, Encode, HasCodec } from './codec/index.mjs';
+export { Convert } from './convert/index.mjs';
+export { Create } from './create/index.mjs';
+export { Default } from './default/index.mjs';
+export { Equal } from './equal/index.mjs';
+export { Errors } from './errors/index.mjs';
+export { Hash } from './hash/index.mjs';
+export { Mutate } from './mutate/index.mjs';
+export { Parse } from './parse/index.mjs';
+export { Diff, Patch } from './delta/index.mjs';
+export { Pointer } from './pointer/index.mjs';
+export { Repair } from './repair/index.mjs';

package/license

@@ -0,0 +1,23 @@
+TypeBox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2025 Haydn Paterson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/package.json

@@ -1,9 +1,77 @@
 {
   "name": "typebox",
-  "version": "0.0.1",
-  "module": "index.ts",
-  "type": "module",
-  "files": [
-    "./index.ts"
-  ]
-}
+  "description": "A Runtime Type System for JavaScript",
+  "version": "1.0.0",
+  "keywords": [
+    "typescript",
+    "jsonschema"
+  ],
+  "license": "MIT",
+  "author": "sinclairzx81",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sinclairzx81/typebox"
+  },
+  "types": "./build/index.d.mts",
+  "module": "./build/index.mjs",
+  "exports": {
+    "./compile": {
+      "import": "./build/compile/index.mjs"
+    },
+    "./error": {
+      "import": "./build/error/index.mjs"
+    },
+    "./format": {
+      "import": "./build/format/index.mjs"
+    },
+    "./guard": {
+      "import": "./build/guard/index.mjs"
+    },
+    "./schema": {
+      "import": "./build/schema/index.mjs"
+    },
+    "./system": {
+      "import": "./build/system/index.mjs"
+    },
+    "./type": {
+      "import": "./build/type/index.mjs"
+    },
+    "./value": {
+      "import": "./build/value/index.mjs"
+    },
+    ".": {
+      "import": "./build/index.mjs"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "compile": [
+        "./build/compile/index.d.mts"
+      ],
+      "error": [
+        "./build/error/index.d.mts"
+      ],
+      "format": [
+        "./build/format/index.d.mts"
+      ],
+      "guard": [
+        "./build/guard/index.d.mts"
+      ],
+      "schema": [
+        "./build/schema/index.d.mts"
+      ],
+      "system": [
+        "./build/system/index.d.mts"
+      ],
+      "type": [
+        "./build/type/index.d.mts"
+      ],
+      "value": [
+        "./build/value/index.d.mts"
+      ],
+      ".": [
+        "./build/./index.d.mts"
+      ]
+    }
+  }
+}