@sinclair/typebox 0.32.0-dev-4 → 0.32.0-dev-5

package/build/import/type/type/json.mjs

@@ -0,0 +1,171 @@
+import { Any } from '../any/index.mjs';
+import { Array } from '../array/index.mjs';
+import { Boolean } from '../boolean/index.mjs';
+import { Composite } from '../composite/index.mjs';
+import { Const } from '../const/index.mjs';
+import { Deref } from '../deref/index.mjs';
+import { Enum } from '../enum/index.mjs';
+import { Exclude } from '../exclude/index.mjs';
+import { Extends } from '../extends/index.mjs';
+import { Extract } from '../extract/index.mjs';
+import { Index } from '../indexed/index.mjs';
+import { Integer } from '../integer/index.mjs';
+import { Intersect } from '../intersect/index.mjs';
+import { Capitalize, Uncapitalize, Lowercase, Uppercase } from '../intrinsic/index.mjs';
+import { KeyOf } from '../keyof/index.mjs';
+import { Literal } from '../literal/index.mjs';
+import { Never } from '../never/index.mjs';
+import { Not } from '../not/index.mjs';
+import { Null } from '../null/index.mjs';
+import { Number } from '../number/index.mjs';
+import { Object } from '../object/index.mjs';
+import { Omit } from '../omit/index.mjs';
+import { Optional } from '../optional/index.mjs';
+import { Partial } from '../partial/index.mjs';
+import { Pick } from '../pick/index.mjs';
+import { Readonly } from '../readonly/index.mjs';
+import { ReadonlyOptional } from '../readonly-optional/index.mjs';
+import { Record } from '../record/index.mjs';
+import { Recursive } from '../recursive/index.mjs';
+import { Ref } from '../ref/index.mjs';
+import { Required } from '../required/index.mjs';
+import { Rest } from '../rest/index.mjs';
+import { Strict } from '../strict/index.mjs';
+import { String } from '../string/index.mjs';
+import { TemplateLiteral } from '../template-literal/index.mjs';
+import { Transform } from '../transform/index.mjs';
+import { Tuple } from '../tuple/index.mjs';
+import { Union } from '../union/index.mjs';
+import { Unknown } from '../unknown/index.mjs';
+import { Unsafe } from '../unsafe/index.mjs';
+export class JsonTypeBuilder {
+    Strict(schema) {
+        return Strict(schema);
+    }
+    ReadonlyOptional(schema) {
+        return ReadonlyOptional(schema);
+    }
+    Readonly(schema) {
+        return Readonly(schema);
+    }
+    Optional(schema) {
+        return Optional(schema);
+    }
+    Any(options = {}) {
+        return Any(options);
+    }
+    Array(schema, options = {}) {
+        return Array(schema, options);
+    }
+    Boolean(options = {}) {
+        return Boolean(options);
+    }
+    Capitalize(schema, options = {}) {
+        return Capitalize(schema, options);
+    }
+    Composite(objects, options) {
+        return Composite(objects, options);
+    }
+    Const(value, options = {}) {
+        return Const(value, options);
+    }
+    Deref(schema, references) {
+        return Deref(schema, references);
+    }
+    Enum(item, options = {}) {
+        return Enum(item, options);
+    }
+    Extends(left, right, trueType, falseType, options = {}) {
+        return Extends(left, right, trueType, falseType, options);
+    }
+    Exclude(unionType, excludedMembers, options = {}) {
+        return Exclude(unionType, excludedMembers, options);
+    }
+    Extract(type, union, options = {}) {
+        return Extract(type, union, options);
+    }
+    Index(schema, unresolved, options = {}) {
+        return Index(schema, unresolved, options);
+    }
+    Integer(options = {}) {
+        return Integer(options);
+    }
+    Intersect(T, options = {}) {
+        return Intersect(T, options);
+    }
+    KeyOf(schema, options = {}) {
+        return KeyOf(schema, options);
+    }
+    Literal(value, options = {}) {
+        return Literal(value, options);
+    }
+    Lowercase(schema, options = {}) {
+        return Lowercase(schema, options);
+    }
+    Never(options = {}) {
+        return Never(options);
+    }
+    Not(schema, options) {
+        return Not(schema, options);
+    }
+    Null(options = {}) {
+        return Null(options);
+    }
+    Number(options = {}) {
+        return Number(options);
+    }
+    Object(properties, options = {}) {
+        return Object(properties, options);
+    }
+    Omit(schema, unresolved, options = {}) {
+        return Omit(schema, unresolved, options);
+    }
+    Partial(schema, options = {}) {
+        return Partial(schema, options);
+    }
+    Pick(schema, unresolved, options = {}) {
+        return Pick(schema, unresolved, options);
+    }
+    Record(key, schema, options = {}) {
+        return Record(key, schema);
+    }
+    Recursive(callback, options = {}) {
+        return Recursive(callback, options);
+    }
+    Ref(unresolved, options = {}) {
+        return Ref(unresolved, options);
+    }
+    Required(schema, options = {}) {
+        return Required(schema, options);
+    }
+    Rest(schema) {
+        return Rest(schema);
+    }
+    String(options = {}) {
+        return String(options);
+    }
+    TemplateLiteral(unresolved, options = {}) {
+        return TemplateLiteral(unresolved, options);
+    }
+    Transform(schema) {
+        return Transform(schema);
+    }
+    Tuple(items, options = {}) {
+        return Tuple(items, options);
+    }
+    Uncapitalize(schema, options = {}) {
+        return Uncapitalize(schema, options);
+    }
+    Union(schemas, options = {}) {
+        return Union(schemas, options);
+    }
+    Unknown(options = {}) {
+        return Unknown(options);
+    }
+    Unsafe(options = {}) {
+        return Unsafe(options);
+    }
+    Uppercase(schema, options = {}) {
+        return Uppercase(schema, options);
+    }
+}

package/build/import/type/type/type.mjs

@@ -0,0 +1,58 @@
+export { Any } from '../any/index.mjs';
+export { Array } from '../array/index.mjs';
+export { AsyncIterator } from '../async-iterator/index.mjs';
+export { Awaited } from '../awaited/index.mjs';
+export { BigInt } from '../bigint/index.mjs';
+export { Boolean } from '../boolean/index.mjs';
+export { Composite } from '../composite/index.mjs';
+export { Const } from '../const/index.mjs';
+export { Constructor } from '../constructor/index.mjs';
+export { ConstructorParameters } from '../constructor-parameters/index.mjs';
+export { Date } from '../date/index.mjs';
+export { Deref } from '../deref/index.mjs';
+export { Enum } from '../enum/index.mjs';
+export { Exclude } from '../exclude/index.mjs';
+export { Extends } from '../extends/index.mjs';
+export { Extract } from '../extract/index.mjs';
+export { Function } from '../function/index.mjs';
+export { Index } from '../indexed/index.mjs';
+export { InstanceType } from '../instance-type/index.mjs';
+export { Integer } from '../integer/index.mjs';
+export { Intersect } from '../intersect/index.mjs';
+export { Capitalize, Uncapitalize, Lowercase, Uppercase } from '../intrinsic/index.mjs';
+export { Iterator } from '../iterator/index.mjs';
+export { KeyOf } from '../keyof/index.mjs';
+export { Literal } from '../literal/index.mjs';
+export { Mapped } from '../mapped/index.mjs';
+export { Never } from '../never/index.mjs';
+export { Not } from '../not/index.mjs';
+export { Null } from '../null/index.mjs';
+export { Number } from '../number/index.mjs';
+export { Object } from '../object/index.mjs';
+export { Omit } from '../omit/index.mjs';
+export { Optional } from '../optional/index.mjs';
+export { Parameters } from '../parameters/index.mjs';
+export { Partial } from '../partial/index.mjs';
+export { Pick } from '../pick/index.mjs';
+export { Promise } from '../promise/index.mjs';
+export { Readonly } from '../readonly/index.mjs';
+export { ReadonlyOptional } from '../readonly-optional/index.mjs';
+export { Record } from '../record/index.mjs';
+export { Recursive } from '../recursive/index.mjs';
+export { Ref } from '../ref/index.mjs';
+export { RegExp } from '../regexp/index.mjs';
+export { Required } from '../required/index.mjs';
+export { Rest } from '../rest/index.mjs';
+export { ReturnType } from '../return-type/index.mjs';
+export { Strict } from '../strict/index.mjs';
+export { String } from '../string/index.mjs';
+export { Symbol } from '../symbol/index.mjs';
+export { TemplateLiteral } from '../template-literal/index.mjs';
+export { Transform } from '../transform/index.mjs';
+export { Tuple } from '../tuple/index.mjs';
+export { Uint8Array } from '../uint8array/index.mjs';
+export { Undefined } from '../undefined/index.mjs';
+export { Union } from '../union/index.mjs';
+export { Unknown } from '../unknown/index.mjs';
+export { Unsafe } from '../unsafe/index.mjs';
+export { Void } from '../void/index.mjs';

package/build/import/type/uint8array/index.mjs

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

package/build/import/type/uint8array/uint8array.mjs

@@ -0,0 +1,4 @@
+import { Kind } from '../symbols/index.mjs';
+export function Uint8Array(options = {}) {
+    return { ...options, [Kind]: 'Uint8Array', type: 'Uint8Array' };
+}

package/build/import/type/undefined/index.mjs

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

package/build/import/type/undefined/undefined.mjs

@@ -0,0 +1,4 @@
+import { Kind } from '../symbols/index.mjs';
+export function Undefined(options = {}) {
+    return { ...options, [Kind]: 'Undefined', type: 'undefined' };
+}

package/build/import/type/union/index.mjs

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

package/build/import/type/union/union.mjs

@@ -0,0 +1,15 @@
+import { Never } from '../never/index.mjs';
+import { OptionalFromUnion } from '../modifiers/index.mjs';
+import { CloneType, CloneRest } from '../clone/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+export function UnionResolve(T) {
+    return (T.length === 0 ? Never() :
+        T.length === 1 ? T[0] :
+            OptionalFromUnion(T));
+}
+export function Union(T, options = {}) {
+    return (T.length === 0 ? Never(options) :
+        T.length === 1 ? CloneType(T[0], options) :
+            { ...options, [Kind]: 'Union', anyOf: CloneRest(T)
+            });
+}

package/build/import/type/unknown/index.mjs

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

package/build/import/type/unknown/unknown.mjs

@@ -0,0 +1,7 @@
+import { Kind } from '../symbols/index.mjs';
+export function Unknown(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Unknown',
+    };
+}

package/build/import/type/unsafe/index.mjs

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

package/build/import/type/unsafe/unsafe.mjs

@@ -0,0 +1,7 @@
+import { Kind } from '../symbols/index.mjs';
+export function Unsafe(options = {}) {
+    return {
+        ...options,
+        [Kind]: options[Kind] ?? 'Unsafe',
+    };
+}

package/build/import/type/void/index.mjs

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

package/build/import/type/void/void.mjs

@@ -0,0 +1,8 @@
+import { Kind } from '../symbols/index.mjs';
+export function Void(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Void',
+        type: 'void',
+    };
+}

package/build/import/value/cast/cast.mjs

@@ -0,0 +1,205 @@
+import { IsPlainObject, IsArray, IsString, IsNumber, IsNull } from '../guard/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 } from '../deref/index.mjs';
+export class ValueCastArrayUniqueItemsTypeError extends Error {
+    schema;
+    value;
+    constructor(schema, value) {
+        super('Array cast produced invalid data due to uniqueItems constraint');
+        this.schema = schema;
+        this.value = value;
+    }
+}
+export class ValueCastNeverTypeError extends Error {
+    schema;
+    constructor(schema) {
+        super('Never types cannot be cast');
+        this.schema = schema;
+    }
+}
+export class ValueCastRecursiveTypeError extends Error {
+    schema;
+    constructor(schema) {
+        super('Cannot cast recursive schemas');
+        this.schema = schema;
+    }
+}
+export class ValueCastUnknownTypeError extends Error {
+    schema;
+    constructor(schema) {
+        super('Unknown type');
+        this.schema = schema;
+    }
+}
+var UnionCastCreate;
+(function (UnionCastCreate) {
+    function Score(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);
+            const [point, max] = [1 / entries.length, entries.length];
+            return entries.reduce((acc, [key, schema]) => {
+                const literal = schema[Kind] === 'Literal' && schema.const === value[key] ? max : 0;
+                const checks = Check(schema, references, value[key]) ? point : 0;
+                const exists = keys.includes(key) ? point : 0;
+                return acc + (literal + checks + exists);
+            }, 0);
+        }
+        else {
+            return Check(schema, references, value) ? 1 : 0;
+        }
+    }
+    function Select(union, references, value) {
+        let [select, best] = [union.anyOf[0], 0];
+        for (const schema of union.anyOf) {
+            const score = Score(schema, references, value);
+            if (score > best) {
+                select = schema;
+                best = score;
+            }
+        }
+        return select;
+    }
+    function Create(union, references, value) {
+        if ('default' in union) {
+            return union.default;
+        }
+        else {
+            const schema = Select(union, references, value);
+            return Cast(schema, references, value);
+        }
+    }
+    UnionCastCreate.Create = Create;
+})(UnionCastCreate || (UnionCastCreate = {}));
+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);
+}
+function TArray(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 ValueCastArrayUniqueItemsTypeError(schema, unique);
+    return unique;
+}
+function TConstructor(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 TIntersect(schema, references, value) {
+    const created = Create(schema, references);
+    const mapped = IsPlainObject(created) && IsPlainObject(value) ? { ...created, ...value } : value;
+    return Check(schema, references, mapped) ? mapped : Create(schema, references);
+}
+function TNever(schema, references, value) {
+    throw new ValueCastNeverTypeError(schema);
+}
+function TObject(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]);
+    }
+    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 TRecord(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 TRef(schema, references, value) {
+    return Visit(Deref(schema, references), references, value);
+}
+function TThis(schema, references, value) {
+    return Visit(Deref(schema, references), references, value);
+}
+function TTuple(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 TUnion(schema, references, value) {
+    return Check(schema, references, value) ? Clone(value) : UnionCastCreate.Create(schema, references, value);
+}
+function Visit(schema, references, value) {
+    const references_ = IsString(schema.$id) ? [...references, schema] : references;
+    const schema_ = schema;
+    switch (schema[Kind]) {
+        case 'Array':
+            return TArray(schema_, references_, value);
+        case 'Constructor':
+            return TConstructor(schema_, references_, value);
+        case 'Intersect':
+            return TIntersect(schema_, references_, value);
+        case 'Never':
+            return TNever(schema_, references_, value);
+        case 'Object':
+            return TObject(schema_, references_, value);
+        case 'Record':
+            return TRecord(schema_, references_, value);
+        case 'Ref':
+            return TRef(schema_, references_, value);
+        case 'This':
+            return TThis(schema_, references_, value);
+        case 'Tuple':
+            return TTuple(schema_, references_, value);
+        case 'Union':
+            return TUnion(schema_, references_, value);
+        case 'Date':
+        case 'Symbol':
+        case 'Uint8Array':
+            return DefaultClone(schema, references, value);
+        default:
+            return Default(schema_, references_, value);
+    }
+}
+export function Cast(...args) {
+    return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1]);
+}

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

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