@sinclair/typebox 0.24.7 → 0.24.8

package/value/delta.js

@@ -1,191 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/value
-
-The MIT License (MIT)
-
-Copyright (c) 2022 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.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeltaValue = exports.EditType = void 0;
-const reflect_1 = require("./reflect");
-const pointer_1 = require("./pointer");
-const clone_1 = require("./clone");
-var FlatValue;
-(function (FlatValue) {
-    function* Undefined(key, value) {
-        yield [key, { type: 'undefined', value }];
-    }
-    function* Null(key, value) {
-        yield [key, { type: 'null', value }];
-    }
-    function* Function(key, value) {
-        yield [key, { type: 'function', value }];
-    }
-    function* Object(key, value) {
-        yield [key, { type: 'object', value }];
-        for (const entry of globalThis.Object.entries(value)) {
-            yield* Visit(`${key}/${entry[0]}`, entry[1]);
-        }
-    }
-    function* Array(key, value) {
-        yield [key, { type: 'array', value }];
-        for (let i = 0; i < value.length; i++) {
-            yield* Visit(`${key}/${i}`, value[i]);
-        }
-    }
-    function* BigInt(key, value) {
-        yield [key, { type: 'bigint', value }];
-    }
-    function* Symbol(key, value) {
-        yield [key, { type: 'symbol', value }];
-    }
-    function* String(key, value) {
-        yield [key, { type: 'string', value }];
-    }
-    function* Boolean(key, value) {
-        yield [key, { type: 'boolean', value }];
-    }
-    function* Number(key, value) {
-        yield [key, { type: 'number', value }];
-    }
-    function* Visit(path, value) {
-        switch ((0, reflect_1.Reflect)(value)) {
-            case 'array':
-                return yield* Array(path, value);
-            case 'bigint':
-                return yield* BigInt(path, value);
-            case 'boolean':
-                return yield* Boolean(path, value);
-            case 'function':
-                return yield* Function(path, value);
-            case 'null':
-                return yield* Null(path, value);
-            case 'number':
-                return yield* Number(path, value);
-            case 'object':
-                return yield* Object(path, value);
-            case 'string':
-                return yield* String(path, value);
-            case 'symbol':
-                return yield* Symbol(path, value);
-            case 'undefined':
-                return yield* Undefined(path, value);
-        }
-    }
-    function* Create(value) {
-        return yield* Visit('', value);
-    }
-    FlatValue.Create = Create;
-})(FlatValue || (FlatValue = {}));
-var EditType;
-(function (EditType) {
-    EditType[EditType["Delete"] = 0] = "Delete";
-    EditType[EditType["Update"] = 1] = "Update";
-    EditType[EditType["Insert"] = 2] = "Insert";
-})(EditType = exports.EditType || (exports.EditType = {}));
-var DeltaValue;
-(function (DeltaValue) {
-    function IsRootUpdate(edits) {
-        return edits.length > 0 && edits[0][0] === EditType.Update && edits[0][1] === '';
-    }
-    function IsNullUpdate(edits) {
-        return edits.length === 0;
-    }
-    function* Updates(mapA, mapB) {
-        for (const [keyB, entryB] of mapB) {
-            if (!mapA.has(keyB))
-                continue;
-            const entryA = mapA.get(keyB);
-            if (entryA.value === entryB.value)
-                continue;
-            if (entryA.type === 'object' && entryB.type === 'object')
-                continue;
-            if (entryA.type === 'array' && entryB.type === 'array')
-                continue;
-            yield [EditType.Update, keyB, entryB.value];
-        }
-    }
-    function* Inserts(mapA, mapB, updates) {
-        const discards = [];
-        for (const [keyB, entryB] of mapB) {
-            if (discards.some((ignore) => keyB.indexOf(ignore) === 0))
-                continue;
-            if (updates.some((update) => keyB.indexOf(update[1]) === 0))
-                continue;
-            if (mapA.has(keyB))
-                continue;
-            if (entryB.type === 'object' || entryB.type === 'array')
-                discards.push(keyB);
-            yield [EditType.Insert, keyB, entryB.value];
-        }
-    }
-    function* Deletes(mapA, mapB) {
-        const discards = [];
-        for (const [keyA, entryA] of mapA) {
-            if (discards.some((discard) => keyA.indexOf(discard) === 0))
-                continue;
-            if (mapB.has(keyA))
-                continue;
-            if (entryA.type === 'object' || entryA.type === 'array')
-                discards.push(keyA);
-            yield [EditType.Delete, keyA];
-        }
-    }
-    function Diff(valueA, valueB) {
-        const mapA = new Map(FlatValue.Create(valueA));
-        const mapB = new Map(FlatValue.Create(valueB));
-        const updates = [...Updates(mapA, mapB)];
-        const inserts = [...Inserts(mapA, mapB, updates)];
-        const deletes = [...Deletes(mapA, mapB)].reverse();
-        return [...updates, ...inserts, ...deletes];
-    }
-    DeltaValue.Diff = Diff;
-    function Edit(valueA, operations) {
-        if (IsRootUpdate(operations)) {
-            return clone_1.CloneValue.Create(operations[0][2]);
-        }
-        if (IsNullUpdate(operations)) {
-            return clone_1.CloneValue.Create(valueA);
-        }
-        const clone = clone_1.CloneValue.Create(valueA);
-        for (const operation of operations) {
-            switch (operation[0]) {
-                case EditType.Insert: {
-                    pointer_1.Pointer.Set(clone, operation[1], operation[2]);
-                    break;
-                }
-                case EditType.Update: {
-                    pointer_1.Pointer.Set(clone, operation[1], operation[2]);
-                    break;
-                }
-                case EditType.Delete: {
-                    pointer_1.Pointer.Delete(clone, operation[1]);
-                    break;
-                }
-            }
-        }
-        return clone;
-    }
-    DeltaValue.Edit = Edit;
-})(DeltaValue = exports.DeltaValue || (exports.DeltaValue = {}));

package/value/pointer.d.ts

@@ -1,12 +0,0 @@
-export declare namespace Pointer {
-    /** Formats the RFC6901 JsonPointer as an array of paths. */
-    function Format(pointer: string): string[];
-    /** Sets the value at the given pointer. If the pointer does not exist it is created. */
-    function Set(value: any, pointer: string, update: any): void;
-    /** Deletes a value at the given pointer. */
-    function Delete(value: any, pointer: string): any[] | undefined;
-    /** True if a value exists at the given pointer */
-    function Has(value: any, pointer: string): boolean;
-    /** Gets the value at the given pointer */
-    function Get(value: any, pointer: string): any;
-}

package/value/pointer.js

@@ -1,110 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/value
-
-The MIT License (MIT)
-
-Copyright (c) 2022 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.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pointer = void 0;
-var Pointer;
-(function (Pointer) {
-    /** Formats the RFC6901 JsonPointer as an array of paths. */
-    function Format(pointer) {
-        if (pointer === '/')
-            return [''];
-        return pointer
-            .split(`/`)
-            .filter((part) => part.length > 0)
-            .map((part) => part.replace(/~0/g, `~`).replace(/~1/g, `/`));
-    }
-    Pointer.Format = Format;
-    /** Sets the value at the given pointer. If the pointer does not exist it is created. */
-    function Set(value, pointer, update) {
-        if (pointer === '')
-            throw Error('Cannot set root value');
-        const path = Format(pointer);
-        let current = value;
-        while (path.length > 1) {
-            const next = path.shift();
-            if (current[next] === undefined)
-                current[next] = {};
-            current = current[next];
-        }
-        current[path.shift()] = update;
-    }
-    Pointer.Set = Set;
-    /** Deletes a value at the given pointer. */
-    function Delete(value, pointer) {
-        if (pointer === '')
-            throw Error('Cannot delete root value');
-        let current = value;
-        const path = Format(pointer);
-        while (path.length > 1) {
-            const next = path.shift();
-            if (current[next] === undefined)
-                return;
-            current = current[next];
-        }
-        if (Array.isArray(current)) {
-            const index = parseInt(path.shift());
-            return current.splice(index, 1);
-        }
-        else {
-            const key = path.shift();
-            delete current[key];
-        }
-    }
-    Pointer.Delete = Delete;
-    /** True if a value exists at the given pointer */
-    function Has(value, pointer) {
-        if (pointer === '')
-            return true;
-        let current = value;
-        const path = Format(pointer);
-        while (path.length > 1) {
-            const next = path.shift();
-            if (current[next] === undefined)
-                return false;
-            current = current[next];
-        }
-        return current[path.shift()] !== undefined;
-    }
-    Pointer.Has = Has;
-    /** Gets the value at the given pointer */
-    function Get(value, pointer) {
-        if (pointer === '')
-            return value;
-        let current = value;
-        const path = Format(pointer);
-        while (path.length > 1) {
-            const next = path.shift();
-            if (current[next] === undefined)
-                return undefined;
-            current = current[next];
-        }
-        return current[path.shift()];
-    }
-    Pointer.Get = Get;
-})(Pointer = exports.Pointer || (exports.Pointer = {}));

package/value/reflect.d.ts

@@ -1,2 +0,0 @@
-export declare type TypeName = 'bigint' | 'symbol' | 'string' | 'boolean' | 'number' | 'function' | 'undefined' | 'null' | 'array' | 'object' | 'never';
-export declare function Reflect(value: any): TypeName;

package/value/reflect.js

@@ -1,42 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/value
-
-The MIT License (MIT)
-
-Copyright (c) 2022 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.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Reflect = void 0;
-function Reflect(value) {
-    if (value === undefined)
-        return 'undefined';
-    if (value === null)
-        return 'null';
-    if (typeof value === 'object' && !globalThis.Array.isArray(value) && value !== null)
-        return 'object';
-    if (typeof value === 'object' && globalThis.Array.isArray(value))
-        return 'array';
-    return typeof value;
-}
-exports.Reflect = Reflect;

package/value/upcast.d.ts

@@ -1,4 +0,0 @@
-import * as Types from '../typebox';
-export declare namespace UpcastValue {
-    function Create<T extends Types.TSchema>(schema: T, value: any): Types.Static<T>;
-}

package/value/upcast.js

@@ -1,247 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/value
-
-The MIT License (MIT)
-
-Copyright (c) 2022 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.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UpcastValue = void 0;
-const Types = require("../typebox");
-const create_1 = require("./create");
-const check_1 = require("./check");
-// --------------------------------------------------------------------------
-// Specialized Union Patch. Because a value can be one of many different
-// unions with properties potentially overlapping, we need a strategy
-// in which to resolve the appropriate schema to patch from.
-//
-// The following will score each union type found within the types anyOf
-// array. Typically this is executed for objects only, so the score is a
-// essentially a tally of how many properties are valid. The reasoning
-// here is the discriminator field would tip the scales in favor of that
-// union if other properties overlap and match.
-// --------------------------------------------------------------------------
-var UpcastUnionValue;
-(function (UpcastUnionValue) {
-    function Score(schema, value) {
-        let score = 0;
-        if (schema[Types.Kind] === 'Object' && typeof value === 'object' && value !== null) {
-            const objectSchema = schema;
-            const entries = globalThis.Object.entries(objectSchema.properties);
-            score += entries.reduce((acc, [key, schema]) => acc + (check_1.CheckValue.Visit(schema, value[key]) ? 1 : 0), 0);
-        }
-        return score;
-    }
-    function Select(schema, value) {
-        let select = schema.anyOf[0];
-        let best = 0;
-        for (const subschema of schema.anyOf) {
-            const score = Score(subschema, value);
-            if (score > best) {
-                select = subschema;
-                best = score;
-            }
-        }
-        return select;
-    }
-    function Create(schema, value) {
-        return check_1.CheckValue.Visit(schema, value) ? value : UpcastValue.Create(Select(schema, value), value);
-    }
-    UpcastUnionValue.Create = Create;
-})(UpcastUnionValue || (UpcastUnionValue = {}));
-var UpcastValue;
-(function (UpcastValue) {
-    const ids = new Map();
-    function Any(schema, value) {
-        return check_1.CheckValue.Visit(schema, value) ? value : create_1.CreateValue.Create(schema);
-    }
-    function Array(schema, value) {
-        if (check_1.CheckValue.Visit(schema, value))
-            return value;
-        if (!globalThis.Array.isArray(value))
-            return create_1.CreateValue.Create(schema);
-        return value.map((element) => Create(schema.items, element));
-    }
-    function Boolean(schema, value) {
-        return check_1.CheckValue.Visit(schema, value) ? value : create_1.CreateValue.Create(schema);
-    }
-    function Constructor(schema, value) {
-        if (check_1.CheckValue.Visit(schema, value))
-            return create_1.CreateValue.Create(schema);
-        const required = new Set(schema.returns.required || []);
-        const result = function () { };
-        for (const [key, property] of globalThis.Object.entries(schema.returns.properties)) {
-            if (!required.has(key) && value.prototype[key] === undefined)
-                continue;
-            result.prototype[key] = Create(property, value.prototype[key]);
-        }
-        return result;
-    }
-    function Enum(schema, value) {
-        return check_1.CheckValue.Visit(schema, value) ? value : create_1.CreateValue.Create(schema);
-    }
-    function Function(schema, value) {
-        return check_1.CheckValue.Visit(schema, value) ? value : create_1.CreateValue.Create(schema);
-    }
-    function Integer(schema, value) {
-        return check_1.CheckValue.Visit(schema, value) ? value : create_1.CreateValue.Create(schema);
-    }
-    function Intersect(schema, value) {
-        return Object(schema, value);
-    }
-    function Literal(schema, value) {
-        return check_1.CheckValue.Visit(schema, value) ? value : create_1.CreateValue.Create(schema);
-    }
-    function Null(schema, value) {
-        return check_1.CheckValue.Visit(schema, value) ? value : create_1.CreateValue.Create(schema);
-    }
-    function Number(schema, value) {
-        return check_1.CheckValue.Visit(schema, value) ? value : create_1.CreateValue.Create(schema);
-    }
-    function Object(schema, value) {
-        if (check_1.CheckValue.Visit(schema, value))
-            return value;
-        if (value === null || typeof value !== 'object')
-            return create_1.CreateValue.Create(schema);
-        ids.set(schema.$id, schema);
-        const required = new Set(schema.required || []);
-        const result = {};
-        for (const [key, property] of globalThis.Object.entries(schema.properties)) {
-            if (!required.has(key) && value[key] === undefined)
-                continue;
-            result[key] = Create(property, value[key]);
-        }
-        return result;
-    }
-    function Promise(schema, value) {
-        return check_1.CheckValue.Visit(schema, value) ? value : create_1.CreateValue.Create(schema);
-    }
-    function Record(schema, value) {
-        if (check_1.CheckValue.Visit(schema, value))
-            return value;
-        if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value))
-            return create_1.CreateValue.Create(schema);
-        const subschemaKey = globalThis.Object.keys(schema.patternProperties)[0];
-        const subschema = schema.patternProperties[subschemaKey];
-        const result = {};
-        for (const [key, property] of globalThis.Object.entries(value)) {
-            result[key] = Create(subschema, property);
-        }
-        return result;
-    }
-    function Recursive(schema, value) {
-        throw Error('Cannot patch recursive schemas');
-    }
-    function Ref(schema, value) {
-        throw Error('Cannot patch referenced schemas');
-    }
-    function Self(schema, value) {
-        if (!ids.has(schema.$ref))
-            throw new Error(`Upcast: Cannot locate schema with $id '${schema.$id}' for referenced type`);
-        return Object(ids.get(schema.$ref), value);
-    }
-    function String(schema, value) {
-        return check_1.CheckValue.Visit(schema, value) ? value : create_1.CreateValue.Create(schema);
-    }
-    function Tuple(schema, value) {
-        if (check_1.CheckValue.Visit(schema, value))
-            return value;
-        if (!globalThis.Array.isArray(value))
-            return create_1.CreateValue.Create(schema);
-        if (schema.items === undefined)
-            return [];
-        return schema.items.map((schema, index) => Create(schema, value[index]));
-    }
-    function Undefined(schema, value) {
-        return check_1.CheckValue.Visit(schema, value) ? value : create_1.CreateValue.Create(schema);
-    }
-    function Union(schema, value) {
-        return UpcastUnionValue.Create(schema, value);
-    }
-    function Uint8Array(schema, value) {
-        return check_1.CheckValue.Visit(schema, value) ? value : create_1.CreateValue.Create(schema);
-    }
-    function Unknown(schema, value) {
-        return check_1.CheckValue.Visit(schema, value) ? value : create_1.CreateValue.Create(schema);
-    }
-    function Void(schema, value) {
-        return check_1.CheckValue.Visit(schema, value) ? value : create_1.CreateValue.Create(schema);
-    }
-    function Create(schema, value) {
-        const anySchema = schema;
-        switch (schema[Types.Kind]) {
-            case 'Any':
-                return Any(anySchema, value);
-            case 'Array':
-                return Array(anySchema, value);
-            case 'Boolean':
-                return Boolean(anySchema, value);
-            case 'Constructor':
-                return Constructor(anySchema, value);
-            case 'Enum':
-                return Enum(anySchema, value);
-            case 'Function':
-                return Function(anySchema, value);
-            case 'Integer':
-                return Integer(anySchema, value);
-            case 'Intersect':
-                return Intersect(anySchema, value);
-            case 'Literal':
-                return Literal(anySchema, value);
-            case 'Null':
-                return Null(anySchema, value);
-            case 'Number':
-                return Number(anySchema, value);
-            case 'Object':
-                return Object(anySchema, value);
-            case 'Promise':
-                return Promise(anySchema, value);
-            case 'Record':
-                return Record(anySchema, value);
-            case 'Rec':
-                return Recursive(anySchema, value);
-            case 'Ref':
-                return Ref(anySchema, value);
-            case 'Self':
-                return Self(anySchema, value);
-            case 'String':
-                return String(anySchema, value);
-            case 'Tuple':
-                return Tuple(anySchema, value);
-            case 'Undefined':
-                return Undefined(anySchema, value);
-            case 'Union':
-                return Union(anySchema, value);
-            case 'Uint8Array':
-                return Uint8Array(anySchema, value);
-            case 'Unknown':
-                return Unknown(anySchema, value);
-            case 'Void':
-                return Void(anySchema, value);
-            default:
-                throw Error(`Unknown schema kind '${schema[Types.Kind]}'`);
-        }
-    }
-    UpcastValue.Create = Create;
-})(UpcastValue = exports.UpcastValue || (exports.UpcastValue = {}));