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

package/esm/value/cast/cast.mjs

@@ -1,260 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/value
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-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.
-
----------------------------------------------------------------------------*/
-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';
-// ------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------
-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;
-    }
-}
-// ------------------------------------------------------------------
-// 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.
-// ------------------------------------------------------------------
-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 = {}));
-// ------------------------------------------------------------------
-// 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 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]);
-    }
-    // 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 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]) {
-        // --------------------------------------------------------------
-        // Structural
-        // --------------------------------------------------------------
-        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);
-        // --------------------------------------------------------------
-        // 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/esm/value/cast/index.mjs

@@ -1,28 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/value
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-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.
-
----------------------------------------------------------------------------*/
-export * from './cast.mjs';

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

@@ -1,10 +0,0 @@
-import type { TSchema } from '../../type/schema/index.mjs';
-import type { Static } from '../../type/static/index.mjs';
-export declare class ValueCheckUnknownTypeError extends Error {
-    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>;