@depup/sinclair__typebox 0.34.48-depup.0

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

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

package/build/esm/value/delta/delta.mjs

@@ -0,0 +1,171 @@
+import { HasPropertyKey, IsStandardObject, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
+import { ValuePointer } from '../pointer/index.mjs';
+import { Clone } from '../clone/index.mjs';
+import { Equal } from '../equal/equal.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
+import { Literal } from '../../type/literal/index.mjs';
+import { Object } from '../../type/object/index.mjs';
+import { String } from '../../type/string/index.mjs';
+import { Unknown } from '../../type/unknown/index.mjs';
+import { Union } from '../../type/union/index.mjs';
+export const Insert = Object({
+    type: Literal('insert'),
+    path: String(),
+    value: Unknown(),
+});
+export const Update = Object({
+    type: Literal('update'),
+    path: String(),
+    value: Unknown(),
+});
+export const Delete = Object({
+    type: Literal('delete'),
+    path: String(),
+});
+export const Edit = Union([Insert, Update, Delete]);
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+export class ValueDiffError extends TypeBoxError {
+    constructor(value, message) {
+        super(message);
+        this.value = value;
+    }
+}
+// ------------------------------------------------------------------
+// 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 };
+}
+// ------------------------------------------------------------------
+// AssertDiffable
+// ------------------------------------------------------------------
+function AssertDiffable(value) {
+    if (globalThis.Object.getOwnPropertySymbols(value).length > 0)
+        throw new ValueDiffError(value, 'Cannot diff objects with symbols');
+}
+// ------------------------------------------------------------------
+// Diffing Generators
+// ------------------------------------------------------------------
+function* ObjectType(path, current, next) {
+    AssertDiffable(current);
+    AssertDiffable(next);
+    if (!IsStandardObject(next))
+        return yield CreateUpdate(path, next);
+    const currentKeys = globalThis.Object.getOwnPropertyNames(current);
+    const nextKeys = globalThis.Object.getOwnPropertyNames(next);
+    // ----------------------------------------------------------------
+    // inserts
+    // ----------------------------------------------------------------
+    for (const key of nextKeys) {
+        if (HasPropertyKey(current, key))
+            continue;
+        yield CreateInsert(`${path}/${key}`, next[key]);
+    }
+    // ----------------------------------------------------------------
+    // updates
+    // ----------------------------------------------------------------
+    for (const key of currentKeys) {
+        if (!HasPropertyKey(next, key))
+            continue;
+        if (Equal(current, next))
+            continue;
+        yield* Visit(`${path}/${key}`, current[key], next[key]);
+    }
+    // ----------------------------------------------------------------
+    // deletes
+    // ----------------------------------------------------------------
+    for (const key of currentKeys) {
+        if (HasPropertyKey(next, key))
+            continue;
+        yield CreateDelete(`${path}/${key}`);
+    }
+}
+function* ArrayType(path, current, next) {
+    if (!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 (!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 (IsStandardObject(current))
+        return yield* ObjectType(path, current, next);
+    if (IsArray(current))
+        return yield* ArrayType(path, current, next);
+    if (IsTypedArray(current))
+        return yield* TypedArrayType(path, current, next);
+    if (IsValueType(current))
+        return yield* ValueType(path, current, next);
+    throw new ValueDiffError(current, 'Unable to diff value');
+}
+// ------------------------------------------------------------------
+// Diff
+// ------------------------------------------------------------------
+export function Diff(current, next) {
+    return [...Visit('', current, next)];
+}
+// ------------------------------------------------------------------
+// Patch
+// ------------------------------------------------------------------
+function IsRootUpdate(edits) {
+    return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update';
+}
+function IsIdentity(edits) {
+    return edits.length === 0;
+}
+export function Patch(current, edits) {
+    if (IsRootUpdate(edits)) {
+        return Clone(edits[0].value);
+    }
+    if (IsIdentity(edits)) {
+        return Clone(current);
+    }
+    const clone = Clone(current);
+    for (const edit of edits) {
+        switch (edit.type) {
+            case 'insert': {
+                ValuePointer.Set(clone, edit.path, edit.value);
+                break;
+            }
+            case 'update': {
+                ValuePointer.Set(clone, edit.path, edit.value);
+                break;
+            }
+            case 'delete': {
+                ValuePointer.Delete(clone, edit.path);
+                break;
+            }
+        }
+    }
+    return clone;
+}

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

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

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

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

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

@@ -0,0 +1,12 @@
+import type { TSchema } from '../../type/schema/index.mjs';
+import type { TRef } from '../../type/ref/index.mjs';
+import type { TThis } from '../../type/recursive/index.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
+export declare class TypeDereferenceError extends TypeBoxError {
+    readonly schema: TRef | TThis;
+    constructor(schema: TRef | TThis);
+}
+/** `[Internal]` Pushes a schema onto references if the schema has an $id and does not exist on references */
+export declare function Pushref(schema: TSchema, references: TSchema[]): TSchema[];
+/** `[Internal]` Dereferences a schema from the references array or throws if not found */
+export declare function Deref(schema: TSchema, references: TSchema[]): TSchema;

package/build/esm/value/deref/deref.mjs

@@ -0,0 +1,29 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
+import { Kind } from '../../type/symbols/index.mjs';
+import { IsString } from '../guard/guard.mjs';
+export class TypeDereferenceError extends TypeBoxError {
+    constructor(schema) {
+        super(`Unable to dereference schema with $id '${schema.$ref}'`);
+        this.schema = schema;
+    }
+}
+function Resolve(schema, references) {
+    const target = references.find((target) => target.$id === schema.$ref);
+    if (target === undefined)
+        throw new TypeDereferenceError(schema);
+    return Deref(target, references);
+}
+/** `[Internal]` Pushes a schema onto references if the schema has an $id and does not exist on references */
+export function Pushref(schema, references) {
+    if (!IsString(schema.$id) || references.some((target) => target.$id === schema.$id))
+        return references;
+    references.push(schema);
+    return references;
+}
+/** `[Internal]` Dereferences a schema from the references array or throws if not found */
+export function Deref(schema, references) {
+    // prettier-ignore
+    return (schema[Kind] === 'This' || schema[Kind] === 'Ref')
+        ? Resolve(schema, references)
+        : schema;
+}

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

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

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

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

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

@@ -0,0 +1,6 @@
+import type { TSchema } from '../../type/schema/index.mjs';
+import type { StaticEncode } from '../../type/static/index.mjs';
+/** Encodes a value or throws if error */
+export declare function Encode<T extends TSchema, Static = StaticEncode<T>, Result extends Static = Static>(schema: T, references: TSchema[], value: unknown): Result;
+/** Encodes a value or throws if error */
+export declare function Encode<T extends TSchema, Static = StaticEncode<T>, Result extends Static = Static>(schema: T, value: unknown): Result;

package/build/esm/value/encode/encode.mjs

@@ -0,0 +1,11 @@
+import { HasTransform, TransformEncode, TransformEncodeCheckError } from '../transform/index.mjs';
+import { Check } from '../check/index.mjs';
+import { Errors } from '../../errors/index.mjs';
+/** Encodes a value or throws if error */
+export function Encode(...args) {
+    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+    const encoded = HasTransform(schema, references) ? TransformEncode(schema, references, value) : value;
+    if (!Check(schema, references, encoded))
+        throw new TransformEncodeCheckError(schema, encoded, Errors(schema, references, encoded).First());
+    return encoded;
+}

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

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

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

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

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

@@ -0,0 +1,2 @@
+/** Returns true if the left value deep-equals the right */
+export declare function Equal<T>(left: T, right: unknown): right is T;

package/build/esm/value/equal/equal.mjs

@@ -0,0 +1,46 @@
+import { IsObject, IsDate, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
+// ------------------------------------------------------------------
+// Equality Checks
+// ------------------------------------------------------------------
+function ObjectType(left, right) {
+    if (!IsObject(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 IsDate(right) && left.getTime() === right.getTime();
+}
+function ArrayType(left, right) {
+    if (!IsArray(right) || left.length !== right.length)
+        return false;
+    return left.every((value, index) => Equal(value, right[index]));
+}
+function TypedArrayType(left, right) {
+    if (!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 */
+export function Equal(left, right) {
+    if (IsDate(left))
+        return DateType(left, right);
+    if (IsTypedArray(left))
+        return TypedArrayType(left, right);
+    if (IsArray(left))
+        return ArrayType(left, right);
+    if (IsObject(left))
+        return ObjectType(left, right);
+    if (IsValueType(left))
+        return ValueType(left, right);
+    throw new Error('ValueEquals: Unable to compare value');
+}

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

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

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

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

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

@@ -0,0 +1,74 @@
+export type ObjectType = Record<PropertyKey, unknown>;
+export type ArrayType = unknown[];
+export type ValueType = null | undefined | symbol | bigint | number | boolean | string;
+export type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+/** Returns true if this value is an async iterator */
+export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<any>;
+/** Returns true if this value is an iterator */
+export declare function IsIterator(value: unknown): value is IterableIterator<any>;
+/** Returns true if this value is not an instance of a class */
+export declare function IsStandardObject(value: unknown): value is ObjectType;
+/** Returns true if this value is an instance of a class */
+export declare function IsInstanceObject(value: unknown): value is ObjectType;
+/** Returns true if this value is a Promise */
+export declare function IsPromise(value: unknown): value is Promise<unknown>;
+/** Returns true if this value is a Date */
+export declare function IsDate(value: unknown): value is Date;
+/** Returns true if this value is an instance of Map<K, T> */
+export declare function IsMap(value: unknown): value is Map<unknown, unknown>;
+/** Returns true if this value is an instance of Set<T> */
+export declare function IsSet(value: unknown): value is Set<unknown>;
+/** Returns true if this value is RegExp */
+export declare function IsRegExp(value: unknown): value is RegExp;
+/** Returns true if this value is a typed array */
+export declare function IsTypedArray(value: unknown): value is TypedArrayType;
+/** Returns true if the value is a Int8Array */
+export declare function IsInt8Array(value: unknown): value is Int8Array;
+/** Returns true if the value is a Uint8Array */
+export declare function IsUint8Array(value: unknown): value is Uint8Array;
+/** Returns true if the value is a Uint8ClampedArray */
+export declare function IsUint8ClampedArray(value: unknown): value is Uint8ClampedArray;
+/** Returns true if the value is a Int16Array */
+export declare function IsInt16Array(value: unknown): value is Int16Array;
+/** Returns true if the value is a Uint16Array */
+export declare function IsUint16Array(value: unknown): value is Uint16Array;
+/** Returns true if the value is a Int32Array */
+export declare function IsInt32Array(value: unknown): value is Int32Array;
+/** Returns true if the value is a Uint32Array */
+export declare function IsUint32Array(value: unknown): value is Uint32Array;
+/** Returns true if the value is a Float32Array */
+export declare function IsFloat32Array(value: unknown): value is Float32Array;
+/** Returns true if the value is a Float64Array */
+export declare function IsFloat64Array(value: unknown): value is Float64Array;
+/** Returns true if the value is a BigInt64Array */
+export declare function IsBigInt64Array(value: unknown): value is BigInt64Array;
+/** Returns true if the value is a BigUint64Array */
+export declare function IsBigUint64Array(value: unknown): value is BigUint64Array;
+/** Returns true if this value has this property key */
+export declare function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is Record<PropertyKey, unknown> & {
+    [_ in K]: unknown;
+};
+/** Returns true of this value is an object type */
+export declare function IsObject(value: unknown): value is ObjectType;
+/** Returns true if this value is an array, but not a typed array */
+export declare function IsArray(value: unknown): value is ArrayType;
+/** Returns true if this value is an undefined */
+export declare function IsUndefined(value: unknown): value is undefined;
+/** Returns true if this value is an null */
+export declare function IsNull(value: unknown): value is null;
+/** Returns true if this value is an boolean */
+export declare function IsBoolean(value: unknown): value is boolean;
+/** Returns true if this value is an number */
+export declare function IsNumber(value: unknown): value is number;
+/** Returns true if this value is an integer */
+export declare function IsInteger(value: unknown): value is number;
+/** Returns true if this value is bigint */
+export declare function IsBigInt(value: unknown): value is bigint;
+/** Returns true if this value is string */
+export declare function IsString(value: unknown): value is string;
+/** Returns true if this value is a function */
+export declare function IsFunction(value: unknown): value is Function;
+/** Returns true if this value is a symbol */
+export declare function IsSymbol(value: unknown): value is symbol;
+/** Returns true if this value is a value type such as number, string, boolean */
+export declare function IsValueType(value: unknown): value is ValueType;

package/build/esm/value/guard/guard.mjs

@@ -0,0 +1,158 @@
+// --------------------------------------------------------------------------
+// Iterators
+// --------------------------------------------------------------------------
+/** Returns true if this value is an async iterator */
+export function IsAsyncIterator(value) {
+    return IsObject(value) && globalThis.Symbol.asyncIterator in value;
+}
+/** Returns true if this value is an iterator */
+export function IsIterator(value) {
+    return IsObject(value) && globalThis.Symbol.iterator in value;
+}
+// --------------------------------------------------------------------------
+// Object Instances
+// --------------------------------------------------------------------------
+/** Returns true if this value is not an instance of a class */
+export function IsStandardObject(value) {
+    return IsObject(value) && (globalThis.Object.getPrototypeOf(value) === Object.prototype || globalThis.Object.getPrototypeOf(value) === null);
+}
+/** Returns true if this value is an instance of a class */
+export function IsInstanceObject(value) {
+    return IsObject(value) && !IsArray(value) && IsFunction(value.constructor) && value.constructor.name !== 'Object';
+}
+// --------------------------------------------------------------------------
+// JavaScript
+// --------------------------------------------------------------------------
+/** Returns true if this value is a Promise */
+export function IsPromise(value) {
+    return value instanceof globalThis.Promise;
+}
+/** Returns true if this value is a Date */
+export function IsDate(value) {
+    return value instanceof Date && globalThis.Number.isFinite(value.getTime());
+}
+/** Returns true if this value is an instance of Map<K, T> */
+export function IsMap(value) {
+    return value instanceof globalThis.Map;
+}
+/** Returns true if this value is an instance of Set<T> */
+export function IsSet(value) {
+    return value instanceof globalThis.Set;
+}
+/** Returns true if this value is RegExp */
+export function IsRegExp(value) {
+    return value instanceof globalThis.RegExp;
+}
+/** Returns true if this value is a typed array */
+export function IsTypedArray(value) {
+    return globalThis.ArrayBuffer.isView(value);
+}
+/** Returns true if the value is a Int8Array */
+export function IsInt8Array(value) {
+    return value instanceof globalThis.Int8Array;
+}
+/** Returns true if the value is a Uint8Array */
+export function IsUint8Array(value) {
+    return value instanceof globalThis.Uint8Array;
+}
+/** Returns true if the value is a Uint8ClampedArray */
+export function IsUint8ClampedArray(value) {
+    return value instanceof globalThis.Uint8ClampedArray;
+}
+/** Returns true if the value is a Int16Array */
+export function IsInt16Array(value) {
+    return value instanceof globalThis.Int16Array;
+}
+/** Returns true if the value is a Uint16Array */
+export function IsUint16Array(value) {
+    return value instanceof globalThis.Uint16Array;
+}
+/** Returns true if the value is a Int32Array */
+export function IsInt32Array(value) {
+    return value instanceof globalThis.Int32Array;
+}
+/** Returns true if the value is a Uint32Array */
+export function IsUint32Array(value) {
+    return value instanceof globalThis.Uint32Array;
+}
+/** Returns true if the value is a Float32Array */
+export function IsFloat32Array(value) {
+    return value instanceof globalThis.Float32Array;
+}
+/** Returns true if the value is a Float64Array */
+export function IsFloat64Array(value) {
+    return value instanceof globalThis.Float64Array;
+}
+/** Returns true if the value is a BigInt64Array */
+export function IsBigInt64Array(value) {
+    return value instanceof globalThis.BigInt64Array;
+}
+/** Returns true if the value is a BigUint64Array */
+export function IsBigUint64Array(value) {
+    return value instanceof globalThis.BigUint64Array;
+}
+// --------------------------------------------------------------------------
+// PropertyKey
+// --------------------------------------------------------------------------
+/** Returns true if this value has this property key */
+export function HasPropertyKey(value, key) {
+    return key in value;
+}
+// --------------------------------------------------------------------------
+// Standard
+// --------------------------------------------------------------------------
+/** Returns true of this value is an object type */
+export function IsObject(value) {
+    return value !== null && typeof value === 'object';
+}
+/** Returns true if this value is an array, but not a typed array */
+export function IsArray(value) {
+    return globalThis.Array.isArray(value) && !globalThis.ArrayBuffer.isView(value);
+}
+/** Returns true if this value is an undefined */
+export function IsUndefined(value) {
+    return value === undefined;
+}
+/** Returns true if this value is an null */
+export function IsNull(value) {
+    return value === null;
+}
+/** Returns true if this value is an boolean */
+export function IsBoolean(value) {
+    return typeof value === 'boolean';
+}
+/** Returns true if this value is an number */
+export function IsNumber(value) {
+    return typeof value === 'number';
+}
+/** Returns true if this value is an integer */
+export function IsInteger(value) {
+    return globalThis.Number.isInteger(value);
+}
+/** Returns true if this value is bigint */
+export function IsBigInt(value) {
+    return typeof value === 'bigint';
+}
+/** Returns true if this value is string */
+export function IsString(value) {
+    return typeof value === 'string';
+}
+/** Returns true if this value is a function */
+export function IsFunction(value) {
+    return typeof value === 'function';
+}
+/** Returns true if this value is a symbol */
+export function IsSymbol(value) {
+    return typeof value === 'symbol';
+}
+/** Returns true if this value is a value type such as number, string, boolean */
+export function IsValueType(value) {
+    // prettier-ignore
+    return (IsBigInt(value) ||
+        IsBoolean(value) ||
+        IsNull(value) ||
+        IsNumber(value) ||
+        IsString(value) ||
+        IsSymbol(value) ||
+        IsUndefined(value));
+}

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

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

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

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

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

@@ -0,0 +1,7 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
+export declare class ValueHashError extends TypeBoxError {
+    readonly value: unknown;
+    constructor(value: unknown);
+}
+/** Creates a FNV1A-64 non cryptographic hash of the given value */
+export declare function Hash(value: unknown): bigint;