@sinclair/typebox 0.32.0-dev-1 → 0.32.0-dev-2

package/value/delta/delta.d.ts

@@ -1,41 +0,0 @@
-import type { Static } from '../../type/static/index';
-export type Insert = Static<typeof Insert>;
-export declare const Insert: import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"insert">;
-    path: import("../../type/string/string").TString;
-    value: import("../../type/unknown/unknown").TUnknown;
-}>;
-export type Update = Static<typeof Update>;
-export declare const Update: import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"update">;
-    path: import("../../type/string/string").TString;
-    value: import("../../type/unknown/unknown").TUnknown;
-}>;
-export type Delete = Static<typeof Delete>;
-export declare const Delete: import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"delete">;
-    path: import("../../type/string/string").TString;
-}>;
-export type Edit = Static<typeof Edit>;
-export declare const Edit: import("../../type/union/union").TUnion<[import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"insert">;
-    path: import("../../type/string/string").TString;
-    value: import("../../type/unknown/unknown").TUnknown;
-}>, import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"update">;
-    path: import("../../type/string/string").TString;
-    value: import("../../type/unknown/unknown").TUnknown;
-}>, import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"delete">;
-    path: import("../../type/string/string").TString;
-}>]>;
-export declare class ValueDeltaObjectWithSymbolKeyError extends Error {
-    readonly key: unknown;
-    constructor(key: unknown);
-}
-export declare class ValueDeltaUnableToDiffUnknownValue extends Error {
-    readonly value: unknown;
-    constructor(value: unknown);
-}
-export declare function Diff(current: unknown, next: unknown): Edit[];
-export declare function Patch<T = any>(current: unknown, edits: Edit[]): T;

package/value/delta/delta.js

@@ -1,199 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@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.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Patch = exports.Diff = exports.ValueDeltaUnableToDiffUnknownValue = exports.ValueDeltaObjectWithSymbolKeyError = exports.Edit = exports.Delete = exports.Update = exports.Insert = void 0;
-const index_1 = require("../guard/index");
-const index_2 = require("../pointer/index");
-const index_3 = require("../clone/index");
-const index_4 = require("../../type/literal/index");
-const index_5 = require("../../type/object/index");
-const index_6 = require("../../type/string/index");
-const index_7 = require("../../type/unknown/index");
-const index_8 = require("../../type/union/index");
-exports.Insert = (0, index_5.Object)({
-    type: (0, index_4.Literal)('insert'),
-    path: (0, index_6.String)(),
-    value: (0, index_7.Unknown)(),
-});
-exports.Update = (0, index_5.Object)({
-    type: (0, index_4.Literal)('update'),
-    path: (0, index_6.String)(),
-    value: (0, index_7.Unknown)(),
-});
-exports.Delete = (0, index_5.Object)({
-    type: (0, index_4.Literal)('delete'),
-    path: (0, index_6.String)(),
-});
-exports.Edit = (0, index_8.Union)([exports.Insert, exports.Update, exports.Delete]);
-// ------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------
-class ValueDeltaObjectWithSymbolKeyError extends Error {
-    constructor(key) {
-        super('Cannot diff objects with symbol keys');
-        this.key = key;
-    }
-}
-exports.ValueDeltaObjectWithSymbolKeyError = ValueDeltaObjectWithSymbolKeyError;
-class ValueDeltaUnableToDiffUnknownValue extends Error {
-    constructor(value) {
-        super('Unable to create diff edits for unknown value');
-        this.value = value;
-    }
-}
-exports.ValueDeltaUnableToDiffUnknownValue = ValueDeltaUnableToDiffUnknownValue;
-// ------------------------------------------------------------------
-// Command Factory
-// ------------------------------------------------------------------
-function CreateUpdate(path, value) {
-    return { type: 'update', path, value };
-}
-function CreateInsert(path, value) {
-    return { type: 'insert', path, value };
-}
-function CreateDelete(path) {
-    return { type: 'delete', path };
-}
-// ------------------------------------------------------------------
-// Diffing Generators
-// ------------------------------------------------------------------
-function* ObjectType(path, current, next) {
-    if (!(0, index_1.IsPlainObject)(next))
-        return yield CreateUpdate(path, next);
-    const currentKeys = [...globalThis.Object.keys(current), ...globalThis.Object.getOwnPropertySymbols(current)];
-    const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)];
-    for (const key of currentKeys) {
-        if ((0, index_1.IsSymbol)(key))
-            throw new ValueDeltaObjectWithSymbolKeyError(key);
-        if ((0, index_1.IsUndefined)(next[key]) && nextKeys.includes(key))
-            yield CreateUpdate(`${path}/${globalThis.String(key)}`, undefined);
-    }
-    for (const key of nextKeys) {
-        if ((0, index_1.IsUndefined)(current[key]) || (0, index_1.IsUndefined)(next[key]))
-            continue;
-        if ((0, index_1.IsSymbol)(key))
-            throw new ValueDeltaObjectWithSymbolKeyError(key);
-        yield* Visit(`${path}/${globalThis.String(key)}`, current[key], next[key]);
-    }
-    for (const key of nextKeys) {
-        if ((0, index_1.IsSymbol)(key))
-            throw new ValueDeltaObjectWithSymbolKeyError(key);
-        if ((0, index_1.IsUndefined)(current[key]))
-            yield CreateInsert(`${path}/${globalThis.String(key)}`, next[key]);
-    }
-    for (const key of currentKeys.reverse()) {
-        if ((0, index_1.IsSymbol)(key))
-            throw new ValueDeltaObjectWithSymbolKeyError(key);
-        if ((0, index_1.IsUndefined)(next[key]) && !nextKeys.includes(key))
-            yield CreateDelete(`${path}/${globalThis.String(key)}`);
-    }
-}
-function* ArrayType(path, current, next) {
-    if (!(0, index_1.IsArray)(next))
-        return yield CreateUpdate(path, next);
-    for (let i = 0; i < Math.min(current.length, next.length); i++) {
-        yield* Visit(`${path}/${i}`, current[i], next[i]);
-    }
-    for (let i = 0; i < next.length; i++) {
-        if (i < current.length)
-            continue;
-        yield CreateInsert(`${path}/${i}`, next[i]);
-    }
-    for (let i = current.length - 1; i >= 0; i--) {
-        if (i < next.length)
-            continue;
-        yield CreateDelete(`${path}/${i}`);
-    }
-}
-function* TypedArrayType(path, current, next) {
-    if (!(0, index_1.IsTypedArray)(next) || current.length !== next.length || globalThis.Object.getPrototypeOf(current).constructor.name !== globalThis.Object.getPrototypeOf(next).constructor.name)
-        return yield CreateUpdate(path, next);
-    for (let i = 0; i < Math.min(current.length, next.length); i++) {
-        yield* Visit(`${path}/${i}`, current[i], next[i]);
-    }
-}
-function* ValueType(path, current, next) {
-    if (current === next)
-        return;
-    yield CreateUpdate(path, next);
-}
-function* Visit(path, current, next) {
-    if ((0, index_1.IsPlainObject)(current))
-        return yield* ObjectType(path, current, next);
-    if ((0, index_1.IsArray)(current))
-        return yield* ArrayType(path, current, next);
-    if ((0, index_1.IsTypedArray)(current))
-        return yield* TypedArrayType(path, current, next);
-    if ((0, index_1.IsValueType)(current))
-        return yield* ValueType(path, current, next);
-    throw new ValueDeltaUnableToDiffUnknownValue(current);
-}
-// ------------------------------------------------------------------
-// Diff
-// ------------------------------------------------------------------
-function Diff(current, next) {
-    return [...Visit('', current, next)];
-}
-exports.Diff = Diff;
-// ------------------------------------------------------------------
-// Patch
-// ------------------------------------------------------------------
-function IsRootUpdate(edits) {
-    return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update';
-}
-function IsIdentity(edits) {
-    return edits.length === 0;
-}
-function Patch(current, edits) {
-    if (IsRootUpdate(edits)) {
-        return (0, index_3.Clone)(edits[0].value);
-    }
-    if (IsIdentity(edits)) {
-        return (0, index_3.Clone)(current);
-    }
-    const clone = (0, index_3.Clone)(current);
-    for (const edit of edits) {
-        switch (edit.type) {
-            case 'insert': {
-                index_2.ValuePointer.Set(clone, edit.path, edit.value);
-                break;
-            }
-            case 'update': {
-                index_2.ValuePointer.Set(clone, edit.path, edit.value);
-                break;
-            }
-            case 'delete': {
-                index_2.ValuePointer.Delete(clone, edit.path);
-                break;
-            }
-        }
-    }
-    return clone;
-}
-exports.Patch = Patch;

package/value/delta/index.d.ts

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

package/value/deref/deref.d.ts

@@ -1,9 +0,0 @@
-import type { TSchema } from '../../type/schema/index';
-import type { TRef } from '../../type/ref/index';
-import type { TThis } from '../../type/recursive/index';
-export declare class TypeDereferenceError extends Error {
-    readonly schema: TRef | TThis;
-    constructor(schema: TRef | TThis);
-}
-/** Dereferences a schema from the references array or throws if not found */
-export declare function Deref(schema: TRef | TThis, references: TSchema[]): TSchema;

package/value/deref/index.d.ts

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

package/value/equal/equal.js

@@ -1,77 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@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.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Equal = void 0;
-const index_1 = require("../guard/index");
-// ------------------------------------------------------------------
-// Equality Checks
-// ------------------------------------------------------------------
-function ObjectType(left, right) {
-    if (!(0, index_1.IsPlainObject)(right))
-        return false;
-    const leftKeys = [...Object.keys(left), ...Object.getOwnPropertySymbols(left)];
-    const rightKeys = [...Object.keys(right), ...Object.getOwnPropertySymbols(right)];
-    if (leftKeys.length !== rightKeys.length)
-        return false;
-    return leftKeys.every((key) => Equal(left[key], right[key]));
-}
-function DateType(left, right) {
-    return (0, index_1.IsDate)(right) && left.getTime() === right.getTime();
-}
-function ArrayType(left, right) {
-    if (!(0, index_1.IsArray)(right) || left.length !== right.length)
-        return false;
-    return left.every((value, index) => Equal(value, right[index]));
-}
-function TypedArrayType(left, right) {
-    if (!(0, index_1.IsTypedArray)(right) || left.length !== right.length || Object.getPrototypeOf(left).constructor.name !== Object.getPrototypeOf(right).constructor.name)
-        return false;
-    return left.every((value, index) => Equal(value, right[index]));
-}
-function ValueType(left, right) {
-    return left === right;
-}
-// ------------------------------------------------------------------
-// Equal
-// ------------------------------------------------------------------
-/** Returns true if the left value deep-equals the right */
-function Equal(left, right) {
-    if ((0, index_1.IsPlainObject)(left))
-        return ObjectType(left, right);
-    if ((0, index_1.IsDate)(left))
-        return DateType(left, right);
-    if ((0, index_1.IsTypedArray)(left))
-        return TypedArrayType(left, right);
-    if ((0, index_1.IsArray)(left))
-        return ArrayType(left, right);
-    if ((0, index_1.IsValueType)(left))
-        return ValueType(left, right);
-    throw new Error('ValueEquals: Unable to compare value');
-}
-exports.Equal = Equal;

package/value/equal/index.d.ts

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

package/value/guard/index.d.ts

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

package/value/hash/hash.js

@@ -1,177 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@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.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hash = exports.ValueHashError = void 0;
-const index_1 = require("../guard/index");
-// ------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------
-class ValueHashError extends Error {
-    constructor(value) {
-        super(`Unable to hash value`);
-        this.value = value;
-    }
-}
-exports.ValueHashError = ValueHashError;
-// ------------------------------------------------------------------
-// ByteMarker
-// ------------------------------------------------------------------
-var ByteMarker;
-(function (ByteMarker) {
-    ByteMarker[ByteMarker["Undefined"] = 0] = "Undefined";
-    ByteMarker[ByteMarker["Null"] = 1] = "Null";
-    ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
-    ByteMarker[ByteMarker["Number"] = 3] = "Number";
-    ByteMarker[ByteMarker["String"] = 4] = "String";
-    ByteMarker[ByteMarker["Object"] = 5] = "Object";
-    ByteMarker[ByteMarker["Array"] = 6] = "Array";
-    ByteMarker[ByteMarker["Date"] = 7] = "Date";
-    ByteMarker[ByteMarker["Uint8Array"] = 8] = "Uint8Array";
-    ByteMarker[ByteMarker["Symbol"] = 9] = "Symbol";
-    ByteMarker[ByteMarker["BigInt"] = 10] = "BigInt";
-})(ByteMarker || (ByteMarker = {}));
-// ------------------------------------------------------------------
-// State
-// ------------------------------------------------------------------
-let Accumulator = BigInt('14695981039346656037');
-const [Prime, Size] = [BigInt('1099511628211'), BigInt('2') ** BigInt('64')];
-const Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i));
-const F64 = new Float64Array(1);
-const F64In = new DataView(F64.buffer);
-const F64Out = new Uint8Array(F64.buffer);
-// ------------------------------------------------------------------
-// NumberToBytes
-// ------------------------------------------------------------------
-function* NumberToBytes(value) {
-    const byteCount = value === 0 ? 1 : Math.ceil(Math.floor(Math.log2(value) + 1) / 8);
-    for (let i = 0; i < byteCount; i++) {
-        yield (value >> (8 * (byteCount - 1 - i))) & 0xff;
-    }
-}
-// ------------------------------------------------------------------
-// Hashing Functions
-// ------------------------------------------------------------------
-function ArrayType(value) {
-    FNV1A64(ByteMarker.Array);
-    for (const item of value) {
-        Visit(item);
-    }
-}
-function BooleanType(value) {
-    FNV1A64(ByteMarker.Boolean);
-    FNV1A64(value ? 1 : 0);
-}
-function BigIntType(value) {
-    FNV1A64(ByteMarker.BigInt);
-    F64In.setBigInt64(0, value);
-    for (const byte of F64Out) {
-        FNV1A64(byte);
-    }
-}
-function DateType(value) {
-    FNV1A64(ByteMarker.Date);
-    Visit(value.getTime());
-}
-function NullType(value) {
-    FNV1A64(ByteMarker.Null);
-}
-function NumberType(value) {
-    FNV1A64(ByteMarker.Number);
-    F64In.setFloat64(0, value);
-    for (const byte of F64Out) {
-        FNV1A64(byte);
-    }
-}
-function ObjectType(value) {
-    FNV1A64(ByteMarker.Object);
-    for (const key of globalThis.Object.keys(value).sort()) {
-        Visit(key);
-        Visit(value[key]);
-    }
-}
-function StringType(value) {
-    FNV1A64(ByteMarker.String);
-    for (let i = 0; i < value.length; i++) {
-        for (const byte of NumberToBytes(value.charCodeAt(i))) {
-            FNV1A64(byte);
-        }
-    }
-}
-function SymbolType(value) {
-    FNV1A64(ByteMarker.Symbol);
-    Visit(value.description);
-}
-function Uint8ArrayType(value) {
-    FNV1A64(ByteMarker.Uint8Array);
-    for (let i = 0; i < value.length; i++) {
-        FNV1A64(value[i]);
-    }
-}
-function UndefinedType(value) {
-    return FNV1A64(ByteMarker.Undefined);
-}
-function Visit(value) {
-    if ((0, index_1.IsArray)(value))
-        return ArrayType(value);
-    if ((0, index_1.IsBoolean)(value))
-        return BooleanType(value);
-    if ((0, index_1.IsBigInt)(value))
-        return BigIntType(value);
-    if ((0, index_1.IsDate)(value))
-        return DateType(value);
-    if ((0, index_1.IsNull)(value))
-        return NullType(value);
-    if ((0, index_1.IsNumber)(value))
-        return NumberType(value);
-    if ((0, index_1.IsPlainObject)(value))
-        return ObjectType(value);
-    if ((0, index_1.IsString)(value))
-        return StringType(value);
-    if ((0, index_1.IsSymbol)(value))
-        return SymbolType(value);
-    if ((0, index_1.IsUint8Array)(value))
-        return Uint8ArrayType(value);
-    if ((0, index_1.IsUndefined)(value))
-        return UndefinedType(value);
-    throw new ValueHashError(value);
-}
-function FNV1A64(byte) {
-    Accumulator = Accumulator ^ Bytes[byte];
-    Accumulator = (Accumulator * Prime) % Size;
-}
-// ------------------------------------------------------------------
-// Hash
-// ------------------------------------------------------------------
-/** Creates a FNV1A-64 non cryptographic hash of the given value */
-function Hash(value) {
-    Accumulator = BigInt('14695981039346656037');
-    Visit(value);
-    return Accumulator;
-}
-exports.Hash = Hash;

package/value/hash/index.d.ts

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

package/value/index.d.ts

@@ -1,18 +0,0 @@
-export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index';
-export { Cast, ValueCastArrayUniqueItemsTypeError, ValueCastNeverTypeError, ValueCastRecursiveTypeError, ValueCastUnknownTypeError } from './cast/index';
-export { Check } from './check/index';
-export { Clean } from './clean/index';
-export { Clone } from './clone/index';
-export { Convert, ValueConvertUnknownTypeError } from './convert/index';
-export { Create, ValueCreateIntersectTypeError, ValueCreateNeverTypeError, ValueCreateNotTypeError, ValueCreateRecursiveInstantiationError, ValueCreateTempateLiteralTypeError, ValueCreateUnknownTypeError } from './create/index';
-export { Default } from './default/index';
-export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaObjectWithSymbolKeyError, ValueDeltaUnableToDiffUnknownValue } from './delta/index';
-export { Equal } from './equal/index';
-export { Hash, ValueHashError } from './hash/index';
-export { Mutate, type Mutable, ValueMutateInvalidRootMutationError, ValueMutateTypeMismatchError } from './mutate/index';
-export { ValuePointer } from './pointer/index';
-export { Decode, Encode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index';
-export { ArrayType, HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, ObjectType, TypedArrayType, ValueType, } from './guard/index';
-import { Value } from './value/index';
-export { Value };
-export default Value;