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

package/build/import/value/transform/decode.mjs

@@ -0,0 +1,160 @@
+import { TTransform as IsTransformType, TSchema as IsSchemaType } from '../../type/guard/type.mjs';
+import { Kind, TransformKind } from '../../type/symbols/index.mjs';
+import { IsPlainObject, IsArray, IsValueType } from '../guard/index.mjs';
+import { KeyOfStringResolve } from '../../type/keyof/index.mjs';
+import { IndexedTypeResolve } from '../../type/indexed/index.mjs';
+import { Deref } from '../deref/index.mjs';
+import { Check } from '../check/index.mjs';
+export class TransformDecodeCheckError extends Error {
+    schema;
+    value;
+    error;
+    constructor(schema, value, error) {
+        super(`Unable to decode due to invalid value`);
+        this.schema = schema;
+        this.value = value;
+        this.error = error;
+    }
+}
+export class TransformDecodeError extends Error {
+    schema;
+    value;
+    constructor(schema, value, error) {
+        super(`${error instanceof Error ? error.message : 'Unknown error'}`);
+        this.schema = schema;
+        this.value = value;
+    }
+}
+function Default(schema, value) {
+    try {
+        return IsTransformType(schema) ? schema[TransformKind].Decode(value) : value;
+    }
+    catch (error) {
+        throw new TransformDecodeError(schema, value, error);
+    }
+}
+function TArray(schema, references, value) {
+    return (IsArray(value))
+        ? Default(schema, value.map((value) => Visit(schema.items, references, value)))
+        : Default(schema, value);
+}
+function TIntersect(schema, references, value) {
+    if (!IsPlainObject(value) || IsValueType(value))
+        return Default(schema, value);
+    const knownKeys = KeyOfStringResolve(schema);
+    const knownProperties = knownKeys.reduce((value, key) => {
+        return (key in value)
+            ? { ...value, [key]: Visit(IndexedTypeResolve(schema, [key]), references, value[key]) }
+            : value;
+    }, value);
+    if (!IsTransformType(schema.unevaluatedProperties)) {
+        return Default(schema, knownProperties);
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+    const unevaluatedProperties = schema.unevaluatedProperties;
+    const unknownProperties = unknownKeys.reduce((value, key) => {
+        return !knownKeys.includes(key)
+            ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }
+            : value;
+    }, knownProperties);
+    return Default(schema, unknownProperties);
+}
+function TNot(schema, references, value) {
+    return Default(schema, Visit(schema.not, references, value));
+}
+function TObject(schema, references, value) {
+    if (!IsPlainObject(value))
+        return Default(schema, value);
+    const knownKeys = KeyOfStringResolve(schema);
+    const knownProperties = knownKeys.reduce((value, key) => {
+        return (key in value)
+            ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }
+            : value;
+    }, value);
+    if (!IsSchemaType(schema.additionalProperties)) {
+        return Default(schema, knownProperties);
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+    const additionalProperties = schema.additionalProperties;
+    const unknownProperties = unknownKeys.reduce((value, key) => {
+        return !knownKeys.includes(key)
+            ? { ...value, [key]: Default(additionalProperties, value[key]) }
+            : value;
+    }, knownProperties);
+    return Default(schema, unknownProperties);
+}
+function TRecord(schema, references, value) {
+    if (!IsPlainObject(value))
+        return Default(schema, value);
+    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+    const knownKeys = new RegExp(pattern);
+    const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
+        return knownKeys.test(key)
+            ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
+            : value;
+    }, value);
+    if (!IsSchemaType(schema.additionalProperties)) {
+        return Default(schema, knownProperties);
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+    const additionalProperties = schema.additionalProperties;
+    const unknownProperties = unknownKeys.reduce((value, key) => {
+        return !knownKeys.test(key)
+            ? { ...value, [key]: Default(additionalProperties, value[key]) }
+            : value;
+    }, knownProperties);
+    return Default(schema, unknownProperties);
+}
+function TRef(schema, references, value) {
+    const target = Deref(schema, references);
+    return Default(schema, Visit(target, references, value));
+}
+function TThis(schema, references, value) {
+    const target = Deref(schema, references);
+    return Default(schema, Visit(target, references, value));
+}
+function TTuple(schema, references, value) {
+    return (IsArray(value) && IsArray(schema.items))
+        ? Default(schema, schema.items.map((schema, index) => Visit(schema, references, value[index])))
+        : Default(schema, value);
+}
+function TUnion(schema, references, value) {
+    for (const subschema of schema.anyOf) {
+        if (!Check(subschema, references, value))
+            continue;
+        const decoded = Visit(subschema, references, value);
+        return Default(schema, decoded);
+    }
+    return Default(schema, value);
+}
+function Visit(schema, references, value) {
+    const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
+    const schema_ = schema;
+    switch (schema[Kind]) {
+        case 'Array':
+            return TArray(schema_, references_, value);
+        case 'Intersect':
+            return TIntersect(schema_, references_, value);
+        case 'Not':
+            return TNot(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 'Symbol':
+            return Default(schema_, value);
+        case 'This':
+            return TThis(schema_, references_, value);
+        case 'Tuple':
+            return TTuple(schema_, references_, value);
+        case 'Union':
+            return TUnion(schema_, references_, value);
+        default:
+            return Default(schema_, value);
+    }
+}
+export function Decode(schema, references, value) {
+    return Visit(schema, references, value);
+}

package/build/import/value/transform/encode.mjs

@@ -0,0 +1,166 @@
+import { TTransform as IsTransformType, TSchema as IsSchemaType } from '../../type/guard/type.mjs';
+import { Kind, TransformKind } from '../../type/symbols/index.mjs';
+import { IsPlainObject, IsArray, IsValueType } from '../guard/index.mjs';
+import { KeyOfStringResolve } from '../../type/keyof/index.mjs';
+import { IndexedTypeResolve } from '../../type/indexed/index.mjs';
+import { Deref } from '../deref/index.mjs';
+import { Check } from '../check/index.mjs';
+export class TransformEncodeCheckError extends Error {
+    schema;
+    value;
+    error;
+    constructor(schema, value, error) {
+        super(`Unable to encode due to invalid value`);
+        this.schema = schema;
+        this.value = value;
+        this.error = error;
+    }
+}
+export class TransformEncodeError extends Error {
+    schema;
+    value;
+    constructor(schema, value, error) {
+        super(`${error instanceof Error ? error.message : 'Unknown error'}`);
+        this.schema = schema;
+        this.value = value;
+    }
+}
+function Default(schema, value) {
+    try {
+        return IsTransformType(schema) ? schema[TransformKind].Encode(value) : value;
+    }
+    catch (error) {
+        throw new TransformEncodeError(schema, value, error);
+    }
+}
+function TArray(schema, references, value) {
+    const defaulted = Default(schema, value);
+    return IsArray(defaulted)
+        ? defaulted.map((value) => Visit(schema.items, references, value))
+        : defaulted;
+}
+function TIntersect(schema, references, value) {
+    const defaulted = Default(schema, value);
+    if (!IsPlainObject(value) || IsValueType(value))
+        return defaulted;
+    const knownKeys = KeyOfStringResolve(schema);
+    const knownProperties = knownKeys.reduce((value, key) => {
+        return key in defaulted
+            ? { ...value, [key]: Visit(IndexedTypeResolve(schema, [key]), references, value[key]) }
+            : value;
+    }, defaulted);
+    if (!IsTransformType(schema.unevaluatedProperties)) {
+        return Default(schema, knownProperties);
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+    const unevaluatedProperties = schema.unevaluatedProperties;
+    return unknownKeys.reduce((value, key) => {
+        return !knownKeys.includes(key)
+            ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }
+            : value;
+    }, knownProperties);
+}
+function TNot(schema, references, value) {
+    return Default(schema.not, Default(schema, value));
+}
+function TObject(schema, references, value) {
+    const defaulted = Default(schema, value);
+    if (!IsPlainObject(value))
+        return defaulted;
+    const knownKeys = KeyOfStringResolve(schema);
+    const knownProperties = knownKeys.reduce((value, key) => {
+        return key in value
+            ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }
+            : value;
+    }, defaulted);
+    if (!IsSchemaType(schema.additionalProperties)) {
+        return knownProperties;
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+    const additionalProperties = schema.additionalProperties;
+    return unknownKeys.reduce((value, key) => {
+        return !knownKeys.includes(key)
+            ? { ...value, [key]: Default(additionalProperties, value[key]) }
+            : value;
+    }, knownProperties);
+}
+function TRecord(schema, references, value) {
+    const defaulted = Default(schema, value);
+    if (!IsPlainObject(value))
+        return defaulted;
+    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+    const knownKeys = new RegExp(pattern);
+    const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
+        return knownKeys.test(key)
+            ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
+            : value;
+    }, defaulted);
+    if (!IsSchemaType(schema.additionalProperties)) {
+        return Default(schema, knownProperties);
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+    const additionalProperties = schema.additionalProperties;
+    return unknownKeys.reduce((value, key) => {
+        return !knownKeys.test(key)
+            ? { ...value, [key]: Default(additionalProperties, value[key]) }
+            : value;
+    }, knownProperties);
+}
+function TRef(schema, references, value) {
+    const target = Deref(schema, references);
+    const resolved = Visit(target, references, value);
+    return Default(schema, resolved);
+}
+function TThis(schema, references, value) {
+    const target = Deref(schema, references);
+    const resolved = Visit(target, references, value);
+    return Default(schema, resolved);
+}
+function TTuple(schema, references, value) {
+    const value1 = Default(schema, value);
+    return IsArray(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, value1[index])) : [];
+}
+function TUnion(schema, references, value) {
+    for (const subschema of schema.anyOf) {
+        if (!Check(subschema, references, value))
+            continue;
+        const value1 = Visit(subschema, references, value);
+        return Default(schema, value1);
+    }
+    for (const subschema of schema.anyOf) {
+        const value1 = Visit(subschema, references, value);
+        if (!Check(schema, references, value1))
+            continue;
+        return Default(schema, value1);
+    }
+    return Default(schema, value);
+}
+function Visit(schema, references, value) {
+    const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
+    const schema_ = schema;
+    switch (schema[Kind]) {
+        case 'Array':
+            return TArray(schema_, references_, value);
+        case 'Intersect':
+            return TIntersect(schema_, references_, value);
+        case 'Not':
+            return TNot(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);
+        default:
+            return Default(schema_, value);
+    }
+}
+export function Encode(schema, references, value) {
+    return Visit(schema, references, value);
+}

package/build/import/value/transform/has.mjs

@@ -0,0 +1,99 @@
+import { TTransform as IsTransformType, TSchema as IsSchemaType } from '../../type/guard/type.mjs';
+import { IsString, IsUndefined } from '../guard/index.mjs';
+import { Deref } from '../deref/index.mjs';
+import { Kind } from '../../type/symbols/index.mjs';
+function TArray(schema, references) {
+    return IsTransformType(schema) || Visit(schema.items, references);
+}
+function TAsyncIterator(schema, references) {
+    return IsTransformType(schema) || Visit(schema.items, references);
+}
+function TConstructor(schema, references) {
+    return IsTransformType(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
+}
+function TFunction(schema, references) {
+    return IsTransformType(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
+}
+function TIntersect(schema, references) {
+    return IsTransformType(schema) || IsTransformType(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references));
+}
+function TIterator(schema, references) {
+    return IsTransformType(schema) || Visit(schema.items, references);
+}
+function TNot(schema, references) {
+    return IsTransformType(schema) || Visit(schema.not, references);
+}
+function TObject(schema, references) {
+    return (IsTransformType(schema) ||
+        Object.values(schema.properties).some((schema) => Visit(schema, references)) ||
+        (IsSchemaType(schema.additionalProperties) && Visit(schema.additionalProperties, references)));
+}
+function TPromise(schema, references) {
+    return IsTransformType(schema) || Visit(schema.item, references);
+}
+function TRecord(schema, references) {
+    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+    const property = schema.patternProperties[pattern];
+    return IsTransformType(schema) || Visit(property, references) || (IsSchemaType(schema.additionalProperties) && IsTransformType(schema.additionalProperties));
+}
+function TRef(schema, references) {
+    if (IsTransformType(schema))
+        return true;
+    return Visit(Deref(schema, references), references);
+}
+function TThis(schema, references) {
+    if (IsTransformType(schema))
+        return true;
+    return Visit(Deref(schema, references), references);
+}
+function TTuple(schema, references) {
+    return IsTransformType(schema) || (!IsUndefined(schema.items) && schema.items.some((schema) => Visit(schema, references)));
+}
+function TUnion(schema, references) {
+    return IsTransformType(schema) || schema.anyOf.some((schema) => Visit(schema, references));
+}
+function Visit(schema, references) {
+    const references_ = IsString(schema.$id) ? [...references, schema] : references;
+    const schema_ = schema;
+    if (schema.$id && visited.has(schema.$id))
+        return false;
+    if (schema.$id)
+        visited.add(schema.$id);
+    switch (schema[Kind]) {
+        case 'Array':
+            return TArray(schema_, references_);
+        case 'AsyncIterator':
+            return TAsyncIterator(schema_, references_);
+        case 'Constructor':
+            return TConstructor(schema_, references_);
+        case 'Function':
+            return TFunction(schema_, references_);
+        case 'Intersect':
+            return TIntersect(schema_, references_);
+        case 'Iterator':
+            return TIterator(schema_, references_);
+        case 'Not':
+            return TNot(schema_, references_);
+        case 'Object':
+            return TObject(schema_, references_);
+        case 'Promise':
+            return TPromise(schema_, references_);
+        case 'Record':
+            return TRecord(schema_, references_);
+        case 'Ref':
+            return TRef(schema_, references_);
+        case 'This':
+            return TThis(schema_, references_);
+        case 'Tuple':
+            return TTuple(schema_, references_);
+        case 'Union':
+            return TUnion(schema_, references_);
+        default:
+            return IsTransformType(schema);
+    }
+}
+const visited = new Set();
+export function HasTransform(schema, references) {
+    visited.clear();
+    return Visit(schema, references);
+}

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

@@ -0,0 +1,65 @@
+import { Decode as DecodeValue, Encode as EncodeValue, TransformDecodeCheckError, TransformEncodeCheckError } from '../transform/index.mjs';
+import { Mutate as MutateValue } from '../mutate/index.mjs';
+import { Hash as HashValue } from '../hash/index.mjs';
+import { Equal as EqualValue } from '../equal/index.mjs';
+import { Cast as CastValue } from '../cast/index.mjs';
+import { Clone as CloneValue } from '../clone/index.mjs';
+import { Convert as ConvertValue } from '../convert/index.mjs';
+import { Create as CreateValue } from '../create/index.mjs';
+import { Clean as CleanValue } from '../clean/index.mjs';
+import { Check as CheckValue } from '../check/index.mjs';
+import { Default as DefaultValue } from '../default/index.mjs';
+import { Diff as DiffValue, Patch as PatchValue } from '../delta/index.mjs';
+import { Errors as ValueErrors } from '../../errors/index.mjs';
+export function Cast(...args) {
+    return CastValue.apply(CastValue, args);
+}
+export function Create(...args) {
+    return CreateValue.apply(CreateValue, args);
+}
+export function Check(...args) {
+    return CheckValue.apply(CheckValue, args);
+}
+export function Clean(...args) {
+    return CleanValue.apply(CleanValue, args);
+}
+export function Convert(...args) {
+    return ConvertValue.apply(ConvertValue, args);
+}
+export function Clone(value) {
+    return CloneValue(value);
+}
+export function Decode(...args) {
+    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+    if (!Check(schema, references, value))
+        throw new TransformDecodeCheckError(schema, value, Errors(schema, references, value).First());
+    return DecodeValue(schema, references, value);
+}
+export function Default(...args) {
+    return DefaultValue.apply(DefaultValue, args);
+}
+export function Encode(...args) {
+    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+    const encoded = EncodeValue(schema, references, value);
+    if (!Check(schema, references, encoded))
+        throw new TransformEncodeCheckError(schema, value, Errors(schema, references, value).First());
+    return encoded;
+}
+export function Errors(...args) {
+    return ValueErrors.apply(ValueErrors, args);
+}
+export function Equal(left, right) {
+    return EqualValue(left, right);
+}
+export function Diff(current, next) {
+    return DiffValue(current, next);
+}
+export function Hash(value) {
+    return HashValue(value);
+}
+export function Patch(current, edits) {
+    return PatchValue(current, edits);
+}
+export function Mutate(current, next) {
+    MutateValue(current, next);
+}

package/build/types/compiler/compiler.d.ts

@@ -0,0 +1,41 @@
+import { ValueErrorIterator } from '../errors/index';
+import type { TSchema } from '../type/schema/index';
+import type { Static, StaticDecode, StaticEncode } from '../type/static/index';
+export type CheckFunction = (value: unknown) => boolean;
+export declare class TypeCheck<T extends TSchema> {
+    private readonly schema;
+    private readonly references;
+    private readonly checkFunc;
+    private readonly code;
+    private readonly hasTransform;
+    constructor(schema: T, references: TSchema[], checkFunc: CheckFunction, code: string);
+    Code(): string;
+    Errors(value: unknown): ValueErrorIterator;
+    Check(value: unknown): value is Static<T>;
+    Decode(value: unknown): StaticDecode<T>;
+    Encode(value: unknown): StaticEncode<T>;
+}
+export declare class TypeCompilerUnknownTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+export declare class TypeCompilerTypeGuardError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+export declare namespace Policy {
+    function IsExactOptionalProperty(value: string, key: string, expression: string): string;
+    function IsObjectLike(value: string): string;
+    function IsRecordLike(value: string): string;
+    function IsNumberLike(value: string): string;
+    function IsVoidLike(value: string): string;
+}
+export type TypeCompilerLanguageOption = 'typescript' | 'javascript';
+export interface TypeCompilerCodegenOptions {
+    language?: TypeCompilerLanguageOption;
+}
+export declare namespace TypeCompiler {
+    function Code<T extends TSchema>(schema: T, references: TSchema[], options?: TypeCompilerCodegenOptions): string;
+    function Code<T extends TSchema>(schema: T, options?: TypeCompilerCodegenOptions): string;
+    function Compile<T extends TSchema>(schema: T, references?: TSchema[]): TypeCheck<T>;
+}

package/build/types/compiler/index.d.ts

@@ -0,0 +1,2 @@
+export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index';
+export * from './compiler';

package/build/types/errors/errors.d.ts

@@ -0,0 +1,86 @@
+import type { TSchema } from '../type/schema/index';
+export declare enum ValueErrorType {
+    ArrayContains = 0,
+    ArrayMaxContains = 1,
+    ArrayMaxItems = 2,
+    ArrayMinContains = 3,
+    ArrayMinItems = 4,
+    ArrayUniqueItems = 5,
+    Array = 6,
+    AsyncIterator = 7,
+    BigIntExclusiveMaximum = 8,
+    BigIntExclusiveMinimum = 9,
+    BigIntMaximum = 10,
+    BigIntMinimum = 11,
+    BigIntMultipleOf = 12,
+    BigInt = 13,
+    Boolean = 14,
+    DateExclusiveMaximumTimestamp = 15,
+    DateExclusiveMinimumTimestamp = 16,
+    DateMaximumTimestamp = 17,
+    DateMinimumTimestamp = 18,
+    DateMultipleOfTimestamp = 19,
+    Date = 20,
+    Function = 21,
+    IntegerExclusiveMaximum = 22,
+    IntegerExclusiveMinimum = 23,
+    IntegerMaximum = 24,
+    IntegerMinimum = 25,
+    IntegerMultipleOf = 26,
+    Integer = 27,
+    IntersectUnevaluatedProperties = 28,
+    Intersect = 29,
+    Iterator = 30,
+    Kind = 31,
+    Literal = 32,
+    Never = 33,
+    Not = 34,
+    Null = 35,
+    NumberExclusiveMaximum = 36,
+    NumberExclusiveMinimum = 37,
+    NumberMaximum = 38,
+    NumberMinimum = 39,
+    NumberMultipleOf = 40,
+    Number = 41,
+    ObjectAdditionalProperties = 42,
+    ObjectMaxProperties = 43,
+    ObjectMinProperties = 44,
+    ObjectRequiredProperty = 45,
+    Object = 46,
+    Promise = 47,
+    StringFormatUnknown = 48,
+    StringFormat = 49,
+    StringMaxLength = 50,
+    StringMinLength = 51,
+    StringPattern = 52,
+    String = 53,
+    Symbol = 54,
+    TupleLength = 55,
+    Tuple = 56,
+    Uint8ArrayMaxByteLength = 57,
+    Uint8ArrayMinByteLength = 58,
+    Uint8Array = 59,
+    Undefined = 60,
+    Union = 61,
+    Void = 62
+}
+export interface ValueError {
+    type: ValueErrorType;
+    schema: TSchema;
+    path: string;
+    value: unknown;
+    message: string;
+}
+export declare class ValueErrorsUnknownTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+export declare function EscapeKey(key: string): string;
+export declare class ValueErrorIterator {
+    private readonly iterator;
+    constructor(iterator: IterableIterator<ValueError>);
+    [Symbol.iterator](): IterableIterator<ValueError>;
+    First(): ValueError | undefined;
+}
+export declare function Errors<T extends TSchema>(schema: T, references: TSchema[], value: unknown): ValueErrorIterator;
+export declare function Errors<T extends TSchema>(schema: T, value: unknown): ValueErrorIterator;

package/build/types/errors/index.d.ts

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