@depup/sinclair__typebox 0.34.48-depup.0

package/build/esm/value/hash/hash.mjs

@@ -0,0 +1,146 @@
+import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+export class ValueHashError extends TypeBoxError {
+    constructor(value) {
+        super(`Unable to hash value`);
+        this.value = value;
+    }
+}
+// ------------------------------------------------------------------
+// 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('18446744073709551616' /* 2 ^ 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.getOwnPropertyNames(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 (IsArray(value))
+        return ArrayType(value);
+    if (IsBoolean(value))
+        return BooleanType(value);
+    if (IsBigInt(value))
+        return BigIntType(value);
+    if (IsDate(value))
+        return DateType(value);
+    if (IsNull(value))
+        return NullType(value);
+    if (IsNumber(value))
+        return NumberType(value);
+    if (IsObject(value))
+        return ObjectType(value);
+    if (IsString(value))
+        return StringType(value);
+    if (IsSymbol(value))
+        return SymbolType(value);
+    if (IsUint8Array(value))
+        return Uint8ArrayType(value);
+    if (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 */
+export function Hash(value) {
+    Accumulator = BigInt('14695981039346656037');
+    Visit(value);
+    return Accumulator;
+}

package/build/esm/value/hash/index.d.mts

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

package/build/esm/value/hash/index.mjs

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

package/build/esm/value/index.d.mts

@@ -0,0 +1,20 @@
+export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
+export * from './guard/index.mjs';
+export * from './assert/index.mjs';
+export * from './cast/index.mjs';
+export * from './check/index.mjs';
+export * from './clean/index.mjs';
+export * from './clone/index.mjs';
+export * from './convert/index.mjs';
+export * from './create/index.mjs';
+export * from './decode/index.mjs';
+export * from './default/index.mjs';
+export * from './delta/index.mjs';
+export * from './encode/index.mjs';
+export * from './equal/index.mjs';
+export * from './hash/index.mjs';
+export * from './mutate/index.mjs';
+export * from './parse/index.mjs';
+export * from './pointer/index.mjs';
+export * from './transform/index.mjs';
+export { Value } from './value/index.mjs';

package/build/esm/value/index.mjs

@@ -0,0 +1,32 @@
+// ------------------------------------------------------------------
+// Errors (re-export)
+// ------------------------------------------------------------------
+export { ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
+export * from './guard/index.mjs';
+// ------------------------------------------------------------------
+// Operators
+// ------------------------------------------------------------------
+export * from './assert/index.mjs';
+export * from './cast/index.mjs';
+export * from './check/index.mjs';
+export * from './clean/index.mjs';
+export * from './clone/index.mjs';
+export * from './convert/index.mjs';
+export * from './create/index.mjs';
+export * from './decode/index.mjs';
+export * from './default/index.mjs';
+export * from './delta/index.mjs';
+export * from './encode/index.mjs';
+export * from './equal/index.mjs';
+export * from './hash/index.mjs';
+export * from './mutate/index.mjs';
+export * from './parse/index.mjs';
+export * from './pointer/index.mjs';
+export * from './transform/index.mjs';
+// ------------------------------------------------------------------
+// Namespace
+// ------------------------------------------------------------------
+export { Value } from './value/index.mjs';

package/build/esm/value/mutate/index.d.mts

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

package/build/esm/value/mutate/index.mjs

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

package/build/esm/value/mutate/mutate.d.mts

@@ -0,0 +1,9 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
+export declare class ValueMutateError extends TypeBoxError {
+    constructor(message: string);
+}
+export type Mutable = {
+    [key: string]: unknown;
+} | unknown[];
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references */
+export declare function Mutate(current: Mutable, next: Mutable): void;

package/build/esm/value/mutate/mutate.mjs

@@ -0,0 +1,98 @@
+import { IsObject, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
+import { ValuePointer } from '../pointer/index.mjs';
+import { Clone } from '../clone/index.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
+// ------------------------------------------------------------------
+// IsStandardObject
+// ------------------------------------------------------------------
+function IsStandardObject(value) {
+    return IsObject(value) && !IsArray(value);
+}
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+export class ValueMutateError extends TypeBoxError {
+    constructor(message) {
+        super(message);
+    }
+}
+function ObjectType(root, path, current, next) {
+    if (!IsStandardObject(current)) {
+        ValuePointer.Set(root, path, Clone(next));
+    }
+    else {
+        const currentKeys = Object.getOwnPropertyNames(current);
+        const nextKeys = Object.getOwnPropertyNames(next);
+        for (const currentKey of currentKeys) {
+            if (!nextKeys.includes(currentKey)) {
+                delete current[currentKey];
+            }
+        }
+        for (const nextKey of nextKeys) {
+            if (!currentKeys.includes(nextKey)) {
+                current[nextKey] = null;
+            }
+        }
+        for (const nextKey of nextKeys) {
+            Visit(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
+        }
+    }
+}
+function ArrayType(root, path, current, next) {
+    if (!IsArray(current)) {
+        ValuePointer.Set(root, path, Clone(next));
+    }
+    else {
+        for (let index = 0; index < next.length; index++) {
+            Visit(root, `${path}/${index}`, current[index], next[index]);
+        }
+        current.splice(next.length);
+    }
+}
+function TypedArrayType(root, path, current, next) {
+    if (IsTypedArray(current) && current.length === next.length) {
+        for (let i = 0; i < current.length; i++) {
+            current[i] = next[i];
+        }
+    }
+    else {
+        ValuePointer.Set(root, path, Clone(next));
+    }
+}
+function ValueType(root, path, current, next) {
+    if (current === next)
+        return;
+    ValuePointer.Set(root, path, next);
+}
+function Visit(root, path, current, next) {
+    if (IsArray(next))
+        return ArrayType(root, path, current, next);
+    if (IsTypedArray(next))
+        return TypedArrayType(root, path, current, next);
+    if (IsStandardObject(next))
+        return ObjectType(root, path, current, next);
+    if (IsValueType(next))
+        return ValueType(root, path, current, next);
+}
+// ------------------------------------------------------------------
+// IsNonMutableValue
+// ------------------------------------------------------------------
+function IsNonMutableValue(value) {
+    return IsTypedArray(value) || IsValueType(value);
+}
+function IsMismatchedValue(current, next) {
+    // prettier-ignore
+    return ((IsStandardObject(current) && IsArray(next)) ||
+        (IsArray(current) && IsStandardObject(next)));
+}
+// ------------------------------------------------------------------
+// Mutate
+// ------------------------------------------------------------------
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references */
+export function Mutate(current, next) {
+    if (IsNonMutableValue(current) || IsNonMutableValue(next))
+        throw new ValueMutateError('Only object and array types can be mutated at the root level');
+    if (IsMismatchedValue(current, next))
+        throw new ValueMutateError('Cannot assign due type mismatch of assignable values');
+    Visit(current, '', current, next);
+}

package/build/esm/value/parse/index.d.mts

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

package/build/esm/value/parse/index.mjs

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

package/build/esm/value/parse/parse.d.mts

@@ -0,0 +1,22 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
+import { TSchema } from '../../type/schema/index.mjs';
+import { StaticDecode } from '../../type/static/index.mjs';
+export declare class ParseError extends TypeBoxError {
+    constructor(message: string);
+}
+export type TParseOperation = 'Assert' | 'Cast' | 'Clean' | 'Clone' | 'Convert' | 'Decode' | 'Default' | 'Encode' | ({} & string);
+export type TParseFunction = (type: TSchema, references: TSchema[], value: unknown) => unknown;
+export declare namespace ParseRegistry {
+    function Delete(key: string): void;
+    function Set(key: string, callback: TParseFunction): void;
+    function Get(key: string): TParseFunction | undefined;
+}
+export declare const ParseDefault: readonly ["Clone", "Clean", "Default", "Convert", "Assert", "Decode"];
+/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
+export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, references: TSchema[], value: unknown): Result;
+/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
+export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, value: unknown): Result;
+/** Parses a value using the specified operations. */
+export declare function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, references: TSchema[], value: unknown): unknown;
+/** Parses a value using the specified operations. */
+export declare function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, value: unknown): unknown;

package/build/esm/value/parse/parse.mjs

@@ -0,0 +1,81 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
+import { TransformDecode, TransformEncode, HasTransform } from '../transform/index.mjs';
+import { Assert } from '../assert/index.mjs';
+import { Cast } from '../cast/index.mjs';
+import { Clean } from '../clean/index.mjs';
+import { Clone } from '../clone/index.mjs';
+import { Convert } from '../convert/index.mjs';
+import { Default } from '../default/index.mjs';
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
+import { IsArray, IsUndefined } from '../guard/index.mjs';
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export class ParseError extends TypeBoxError {
+    constructor(message) {
+        super(message);
+    }
+}
+// prettier-ignore
+export var ParseRegistry;
+(function (ParseRegistry) {
+    const registry = new Map([
+        ['Assert', (type, references, value) => { Assert(type, references, value); return value; }],
+        ['Cast', (type, references, value) => Cast(type, references, value)],
+        ['Clean', (type, references, value) => Clean(type, references, value)],
+        ['Clone', (_type, _references, value) => Clone(value)],
+        ['Convert', (type, references, value) => Convert(type, references, value)],
+        ['Decode', (type, references, value) => (HasTransform(type, references) ? TransformDecode(type, references, value) : value)],
+        ['Default', (type, references, value) => Default(type, references, value)],
+        ['Encode', (type, references, value) => (HasTransform(type, references) ? TransformEncode(type, references, value) : value)],
+    ]);
+    // Deletes an entry from the registry
+    function Delete(key) {
+        registry.delete(key);
+    }
+    ParseRegistry.Delete = Delete;
+    // Sets an entry in the registry
+    function Set(key, callback) {
+        registry.set(key, callback);
+    }
+    ParseRegistry.Set = Set;
+    // Gets an entry in the registry
+    function Get(key) {
+        return registry.get(key);
+    }
+    ParseRegistry.Get = Get;
+})(ParseRegistry || (ParseRegistry = {}));
+// ------------------------------------------------------------------
+// Default Parse Pipeline
+// ------------------------------------------------------------------
+// prettier-ignore
+export const ParseDefault = [
+    'Clone',
+    'Clean',
+    'Default',
+    'Convert',
+    'Assert',
+    'Decode'
+];
+// ------------------------------------------------------------------
+// ParseValue
+// ------------------------------------------------------------------
+function ParseValue(operations, type, references, value) {
+    return operations.reduce((value, operationKey) => {
+        const operation = ParseRegistry.Get(operationKey);
+        if (IsUndefined(operation))
+            throw new ParseError(`Unable to find Parse operation '${operationKey}'`);
+        return operation(type, references, value);
+    }, value);
+}
+/** Parses a value */
+export function Parse(...args) {
+    // prettier-ignore
+    const [operations, schema, references, value] = (args.length === 4 ? [args[0], args[1], args[2], args[3]] :
+        args.length === 3 ? IsArray(args[0]) ? [args[0], args[1], [], args[2]] : [ParseDefault, args[0], args[1], args[2]] :
+            args.length === 2 ? [ParseDefault, args[0], [], args[1]] :
+                (() => { throw new ParseError('Invalid Arguments'); })());
+    return ParseValue(operations, schema, references, value);
+}

package/build/esm/value/pointer/index.d.mts

@@ -0,0 +1 @@
+export * as ValuePointer from './pointer.mjs';

package/build/esm/value/pointer/index.mjs

@@ -0,0 +1 @@
+export * as ValuePointer from './pointer.mjs';

package/build/esm/value/pointer/pointer.d.mts

@@ -0,0 +1,22 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
+export declare class ValuePointerRootSetError extends TypeBoxError {
+    readonly value: unknown;
+    readonly path: string;
+    readonly update: unknown;
+    constructor(value: unknown, path: string, update: unknown);
+}
+export declare class ValuePointerRootDeleteError extends TypeBoxError {
+    readonly value: unknown;
+    readonly path: string;
+    constructor(value: unknown, path: string);
+}
+/** Formats the given pointer into navigable key components */
+export declare function Format(pointer: string): IterableIterator<string>;
+/** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
+export declare function Set(value: any, pointer: string, update: unknown): void;
+/** Deletes a value at the given pointer */
+export declare function Delete(value: any, pointer: string): void;
+/** Returns true if a value exists at the given pointer */
+export declare function Has(value: any, pointer: string): boolean;
+/** Gets the value at the given pointer */
+export declare function Get(value: any, pointer: string): any;

package/build/esm/value/pointer/pointer.mjs

@@ -0,0 +1,115 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+export class ValuePointerRootSetError extends TypeBoxError {
+    constructor(value, path, update) {
+        super('Cannot set root value');
+        this.value = value;
+        this.path = path;
+        this.update = update;
+    }
+}
+export class ValuePointerRootDeleteError extends TypeBoxError {
+    constructor(value, path) {
+        super('Cannot delete root value');
+        this.value = value;
+        this.path = path;
+    }
+}
+// ------------------------------------------------------------------
+// ValuePointer
+// ------------------------------------------------------------------
+/** Provides functionality to update values through RFC6901 string pointers */
+// prettier-ignore
+function Escape(component) {
+    return component.indexOf('~') === -1 ? component : component.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+/** Formats the given pointer into navigable key components */
+// prettier-ignore
+export function* Format(pointer) {
+    if (pointer === '')
+        return;
+    let [start, end] = [0, 0];
+    for (let i = 0; i < pointer.length; i++) {
+        const char = pointer.charAt(i);
+        if (char === '/') {
+            if (i === 0) {
+                start = i + 1;
+            }
+            else {
+                end = i;
+                yield Escape(pointer.slice(start, end));
+                start = i + 1;
+            }
+        }
+        else {
+            end = i;
+        }
+    }
+    yield Escape(pointer.slice(start));
+}
+/** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
+// prettier-ignore
+export function Set(value, pointer, update) {
+    if (pointer === '')
+        throw new ValuePointerRootSetError(value, pointer, update);
+    let [owner, next, key] = [null, value, ''];
+    for (const component of Format(pointer)) {
+        if (next[component] === undefined)
+            next[component] = {};
+        owner = next;
+        next = next[component];
+        key = component;
+    }
+    owner[key] = update;
+}
+/** Deletes a value at the given pointer */
+// prettier-ignore
+export function Delete(value, pointer) {
+    if (pointer === '')
+        throw new ValuePointerRootDeleteError(value, pointer);
+    let [owner, next, key] = [null, value, ''];
+    for (const component of Format(pointer)) {
+        if (next[component] === undefined || next[component] === null)
+            return;
+        owner = next;
+        next = next[component];
+        key = component;
+    }
+    if (Array.isArray(owner)) {
+        const index = parseInt(key);
+        owner.splice(index, 1);
+    }
+    else {
+        delete owner[key];
+    }
+}
+/** Returns true if a value exists at the given pointer */
+// prettier-ignore
+export function Has(value, pointer) {
+    if (pointer === '')
+        return true;
+    let [owner, next, key] = [null, value, ''];
+    for (const component of Format(pointer)) {
+        if (next[component] === undefined)
+            return false;
+        owner = next;
+        next = next[component];
+        key = component;
+    }
+    return Object.getOwnPropertyNames(owner).includes(key);
+}
+/** Gets the value at the given pointer */
+// prettier-ignore
+export function Get(value, pointer) {
+    if (pointer === '')
+        return value;
+    let current = value;
+    for (const component of Format(pointer)) {
+        if (current[component] === undefined)
+            return undefined;
+        current = current[component];
+    }
+    return current;
+}

package/build/esm/value/transform/decode.d.mts

@@ -0,0 +1,22 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
+import { ValueError } from '../../errors/index.mjs';
+import type { TSchema } from '../../type/schema/index.mjs';
+export declare class TransformDecodeCheckError extends TypeBoxError {
+    readonly schema: TSchema;
+    readonly value: unknown;
+    readonly error: ValueError;
+    constructor(schema: TSchema, value: unknown, error: ValueError);
+}
+export declare class TransformDecodeError extends TypeBoxError {
+    readonly schema: TSchema;
+    readonly path: string;
+    readonly value: unknown;
+    readonly error: Error;
+    constructor(schema: TSchema, path: string, value: unknown, error: Error);
+}
+/**
+ * `[Internal]` Decodes the value and returns the result. This function requires that
+ * the caller `Check` the value before use. Passing unchecked values may result in
+ * undefined behavior. Refer to the `Value.Decode()` for implementation details.
+ */
+export declare function TransformDecode(schema: TSchema, references: TSchema[], value: unknown): unknown;