@depup/sinclair__typebox 0.34.48-depup.0

package/build/esm/value/assert/assert.mjs

@@ -0,0 +1,49 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AssertError_instances, _AssertError_iterator, _AssertError_Iterator;
+import { Errors, ValueErrorIterator } from '../../errors/index.mjs';
+import { TypeBoxError } from '../../type/error/error.mjs';
+import { Check } from '../check/check.mjs';
+// ------------------------------------------------------------------
+// AssertError
+// ------------------------------------------------------------------
+export class AssertError extends TypeBoxError {
+    constructor(iterator) {
+        const error = iterator.First();
+        super(error === undefined ? 'Invalid Value' : error.message);
+        _AssertError_instances.add(this);
+        _AssertError_iterator.set(this, void 0);
+        __classPrivateFieldSet(this, _AssertError_iterator, iterator, "f");
+        this.error = error;
+    }
+    /** Returns an iterator for each error in this value. */
+    Errors() {
+        return new ValueErrorIterator(__classPrivateFieldGet(this, _AssertError_instances, "m", _AssertError_Iterator).call(this));
+    }
+}
+_AssertError_iterator = new WeakMap(), _AssertError_instances = new WeakSet(), _AssertError_Iterator = function* _AssertError_Iterator() {
+    if (this.error)
+        yield this.error;
+    yield* __classPrivateFieldGet(this, _AssertError_iterator, "f");
+};
+// ------------------------------------------------------------------
+// AssertValue
+// ------------------------------------------------------------------
+function AssertValue(schema, references, value) {
+    if (Check(schema, references, value))
+        return;
+    throw new AssertError(Errors(schema, references, value));
+}
+/** Asserts a value matches the given type or throws an `AssertError` if invalid */
+export function Assert(...args) {
+    return args.length === 3 ? AssertValue(args[0], args[1], args[2]) : AssertValue(args[0], [], args[1]);
+}

package/build/esm/value/assert/index.d.mts

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

package/build/esm/value/assert/index.mjs

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

package/build/esm/value/cast/cast.d.mts

@@ -0,0 +1,11 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
+import type { TSchema } from '../../type/schema/index.mjs';
+import type { Static } from '../../type/static/index.mjs';
+export declare class ValueCastError extends TypeBoxError {
+    readonly schema: TSchema;
+    constructor(schema: TSchema, message: string);
+}
+/** Casts a value into a given type and references. The return value will retain as much information of the original value as possible. */
+export declare function Cast<T extends TSchema>(schema: T, references: TSchema[], value: unknown): Static<T>;
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
+export declare function Cast<T extends TSchema>(schema: T, value: unknown): Static<T>;

package/build/esm/value/cast/cast.mjs

@@ -0,0 +1,235 @@
+import { IsObject, IsArray, IsString, IsNumber, IsNull } from '../guard/index.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
+import { Kind } from '../../type/symbols/index.mjs';
+import { Create } from '../create/index.mjs';
+import { Check } from '../check/index.mjs';
+import { Clone } from '../clone/index.mjs';
+import { Deref, Pushref } from '../deref/index.mjs';
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+export class ValueCastError extends TypeBoxError {
+    constructor(schema, message) {
+        super(message);
+        this.schema = schema;
+    }
+}
+// ------------------------------------------------------------------
+// The following logic assigns a score to a schema based on how well
+// it matches a given value. For object types, the score is calculated
+// by evaluating each property of the value against the schema's
+// properties. To avoid bias towards objects with many properties,
+// each property contributes equally to the total score. Properties
+// that exactly match literal values receive the highest possible
+// score, as literals are often used as discriminators in union types.
+// ------------------------------------------------------------------
+function ScoreUnion(schema, references, value) {
+    if (schema[Kind] === 'Object' && typeof value === 'object' && !IsNull(value)) {
+        const object = schema;
+        const keys = Object.getOwnPropertyNames(value);
+        const entries = Object.entries(object.properties);
+        return entries.reduce((acc, [key, schema]) => {
+            const literal = schema[Kind] === 'Literal' && schema.const === value[key] ? 100 : 0;
+            const checks = Check(schema, references, value[key]) ? 10 : 0;
+            const exists = keys.includes(key) ? 1 : 0;
+            return acc + (literal + checks + exists);
+        }, 0);
+    }
+    else if (schema[Kind] === 'Union') {
+        const schemas = schema.anyOf.map((schema) => Deref(schema, references));
+        const scores = schemas.map((schema) => ScoreUnion(schema, references, value));
+        return Math.max(...scores);
+    }
+    else {
+        return Check(schema, references, value) ? 1 : 0;
+    }
+}
+function SelectUnion(union, references, value) {
+    const schemas = union.anyOf.map((schema) => Deref(schema, references));
+    let [select, best] = [schemas[0], 0];
+    for (const schema of schemas) {
+        const score = ScoreUnion(schema, references, value);
+        if (score > best) {
+            select = schema;
+            best = score;
+        }
+    }
+    return select;
+}
+function CastUnion(union, references, value) {
+    if ('default' in union) {
+        return typeof value === 'function' ? union.default : Clone(union.default);
+    }
+    else {
+        const schema = SelectUnion(union, references, value);
+        return Cast(schema, references, value);
+    }
+}
+// ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
+function DefaultClone(schema, references, value) {
+    return Check(schema, references, value) ? Clone(value) : Create(schema, references);
+}
+function Default(schema, references, value) {
+    return Check(schema, references, value) ? value : Create(schema, references);
+}
+// ------------------------------------------------------------------
+// Cast
+// ------------------------------------------------------------------
+function FromArray(schema, references, value) {
+    if (Check(schema, references, value))
+        return Clone(value);
+    const created = IsArray(value) ? Clone(value) : Create(schema, references);
+    const minimum = IsNumber(schema.minItems) && created.length < schema.minItems ? [...created, ...Array.from({ length: schema.minItems - created.length }, () => null)] : created;
+    const maximum = IsNumber(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum;
+    const casted = maximum.map((value) => Visit(schema.items, references, value));
+    if (schema.uniqueItems !== true)
+        return casted;
+    const unique = [...new Set(casted)];
+    if (!Check(schema, references, unique))
+        throw new ValueCastError(schema, 'Array cast produced invalid data due to uniqueItems constraint');
+    return unique;
+}
+function FromConstructor(schema, references, value) {
+    if (Check(schema, references, value))
+        return Create(schema, references);
+    const required = new Set(schema.returns.required || []);
+    const result = function () { };
+    for (const [key, property] of Object.entries(schema.returns.properties)) {
+        if (!required.has(key) && value.prototype[key] === undefined)
+            continue;
+        result.prototype[key] = Visit(property, references, value.prototype[key]);
+    }
+    return result;
+}
+function FromImport(schema, references, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    return Visit(target, [...references, ...definitions], value);
+}
+// ------------------------------------------------------------------
+// Intersect
+// ------------------------------------------------------------------
+function IntersectAssign(correct, value) {
+    // trust correct on mismatch | value on non-object
+    if ((IsObject(correct) && !IsObject(value)) || (!IsObject(correct) && IsObject(value)))
+        return correct;
+    if (!IsObject(correct) || !IsObject(value))
+        return value;
+    return globalThis.Object.getOwnPropertyNames(correct).reduce((result, key) => {
+        const property = key in value ? IntersectAssign(correct[key], value[key]) : correct[key];
+        return { ...result, [key]: property };
+    }, {});
+}
+function FromIntersect(schema, references, value) {
+    if (Check(schema, references, value))
+        return value;
+    const correct = Create(schema, references);
+    const assigned = IntersectAssign(correct, value);
+    return Check(schema, references, assigned) ? assigned : correct;
+}
+function FromNever(schema, references, value) {
+    throw new ValueCastError(schema, 'Never types cannot be cast');
+}
+function FromObject(schema, references, value) {
+    if (Check(schema, references, value))
+        return value;
+    if (value === null || typeof value !== 'object')
+        return Create(schema, references);
+    const required = new Set(schema.required || []);
+    const result = {};
+    for (const [key, property] of Object.entries(schema.properties)) {
+        if (!required.has(key) && value[key] === undefined)
+            continue;
+        result[key] = Visit(property, references, value[key]);
+    }
+    // additional schema properties
+    if (typeof schema.additionalProperties === 'object') {
+        const propertyNames = Object.getOwnPropertyNames(schema.properties);
+        for (const propertyName of Object.getOwnPropertyNames(value)) {
+            if (propertyNames.includes(propertyName))
+                continue;
+            result[propertyName] = Visit(schema.additionalProperties, references, value[propertyName]);
+        }
+    }
+    return result;
+}
+function FromRecord(schema, references, value) {
+    if (Check(schema, references, value))
+        return Clone(value);
+    if (value === null || typeof value !== 'object' || Array.isArray(value) || value instanceof Date)
+        return Create(schema, references);
+    const subschemaPropertyName = Object.getOwnPropertyNames(schema.patternProperties)[0];
+    const subschema = schema.patternProperties[subschemaPropertyName];
+    const result = {};
+    for (const [propKey, propValue] of Object.entries(value)) {
+        result[propKey] = Visit(subschema, references, propValue);
+    }
+    return result;
+}
+function FromRef(schema, references, value) {
+    return Visit(Deref(schema, references), references, value);
+}
+function FromThis(schema, references, value) {
+    return Visit(Deref(schema, references), references, value);
+}
+function FromTuple(schema, references, value) {
+    if (Check(schema, references, value))
+        return Clone(value);
+    if (!IsArray(value))
+        return Create(schema, references);
+    if (schema.items === undefined)
+        return [];
+    return schema.items.map((schema, index) => Visit(schema, references, value[index]));
+}
+function FromUnion(schema, references, value) {
+    return Check(schema, references, value) ? Clone(value) : CastUnion(schema, references, value);
+}
+function Visit(schema, references, value) {
+    const references_ = IsString(schema.$id) ? Pushref(schema, references) : references;
+    const schema_ = schema;
+    switch (schema[Kind]) {
+        // --------------------------------------------------------------
+        // Structural
+        // --------------------------------------------------------------
+        case 'Array':
+            return FromArray(schema_, references_, value);
+        case 'Constructor':
+            return FromConstructor(schema_, references_, value);
+        case 'Import':
+            return FromImport(schema_, references_, value);
+        case 'Intersect':
+            return FromIntersect(schema_, references_, value);
+        case 'Never':
+            return FromNever(schema_, references_, value);
+        case 'Object':
+            return FromObject(schema_, references_, value);
+        case 'Record':
+            return FromRecord(schema_, references_, value);
+        case 'Ref':
+            return FromRef(schema_, references_, value);
+        case 'This':
+            return FromThis(schema_, references_, value);
+        case 'Tuple':
+            return FromTuple(schema_, references_, value);
+        case 'Union':
+            return FromUnion(schema_, references_, value);
+        // --------------------------------------------------------------
+        // DefaultClone
+        // --------------------------------------------------------------
+        case 'Date':
+        case 'Symbol':
+        case 'Uint8Array':
+            return DefaultClone(schema, references, value);
+        // --------------------------------------------------------------
+        // Default
+        // --------------------------------------------------------------
+        default:
+            return Default(schema_, references_, value);
+    }
+}
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
+export function Cast(...args) {
+    return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1]);
+}

package/build/esm/value/cast/index.d.mts

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

package/build/esm/value/cast/index.mjs

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

package/build/esm/value/check/check.d.mts

@@ -0,0 +1,11 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
+import type { TSchema } from '../../type/schema/index.mjs';
+import type { Static } from '../../type/static/index.mjs';
+export declare class ValueCheckUnknownTypeError extends TypeBoxError {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+/** Returns true if the value matches the given type. */
+export declare function Check<T extends TSchema>(schema: T, references: TSchema[], value: unknown): value is Static<T>;
+/** Returns true if the value matches the given type. */
+export declare function Check<T extends TSchema>(schema: T, value: unknown): value is Static<T>;