@sinclair/typebox 0.31.28 → 0.32.0-dev-2

package/value/cast.d.ts

@@ -1,24 +0,0 @@
-import * as Types from '../typebox';
-export declare class ValueCastArrayUniqueItemsTypeError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    readonly value: unknown;
-    constructor(schema: Types.TSchema, value: unknown);
-}
-export declare class ValueCastNeverTypeError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
-}
-export declare class ValueCastRecursiveTypeError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
-}
-export declare class ValueCastUnknownTypeError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
-}
-export declare function DefaultClone(schema: Types.TSchema, references: Types.TSchema[], value: any): any;
-export declare function Default(schema: Types.TSchema, references: Types.TSchema[], value: any): any;
-/** Casts a value into a given type and references. The return value will retain as much information of the original value as possible. */
-export declare function Cast<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): Types.Static<T>;
-/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
-export declare function Cast<T extends Types.TSchema>(schema: T, value: unknown): Types.Static<T>;

package/value/check.d.ts

@@ -1,9 +0,0 @@
-import * as Types from '../typebox';
-export declare class ValueCheckUnknownTypeError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
-}
-/** Returns true if the value matches the given type. */
-export declare function Check<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): value is Types.Static<T>;
-/** Returns true if the value matches the given type. */
-export declare function Check<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>;

package/value/convert.d.ts

@@ -1,10 +0,0 @@
-import * as Types from '../typebox';
-export declare class ValueConvertUnknownTypeError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
-}
-export declare function Default(value: any): any;
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
-export declare function Convert<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): unknown;
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
-export declare function Convert<T extends Types.TSchema>(schema: T, value: unknown): unknown;

package/value/create.d.ts

@@ -1,30 +0,0 @@
-import * as Types from '../typebox';
-export declare class ValueCreateUnknownTypeError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
-}
-export declare class ValueCreateNeverTypeError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
-}
-export declare class ValueCreateNotTypeError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
-}
-export declare class ValueCreateIntersectTypeError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
-}
-export declare class ValueCreateTempateLiteralTypeError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
-}
-export declare class ValueCreateRecursiveInstantiationError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    readonly recursiveMaxDepth: number;
-    constructor(schema: Types.TSchema, recursiveMaxDepth: number);
-}
-/** Creates a value from the given schema and references */
-export declare function Create<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T>;
-/** Creates a value from the given schema */
-export declare function Create<T extends Types.TSchema>(schema: T): Types.Static<T>;

package/value/delta.d.ts

@@ -1,41 +0,0 @@
-import { Static } from '../typebox';
-export type Insert = Static<typeof Insert>;
-export declare const Insert: import("../typebox").TObject<{
-    type: import("../typebox").TLiteral<"insert">;
-    path: import("../typebox").TString;
-    value: import("../typebox").TUnknown;
-}>;
-export type Update = Static<typeof Update>;
-export declare const Update: import("../typebox").TObject<{
-    type: import("../typebox").TLiteral<"update">;
-    path: import("../typebox").TString;
-    value: import("../typebox").TUnknown;
-}>;
-export type Delete = Static<typeof Delete>;
-export declare const Delete: import("../typebox").TObject<{
-    type: import("../typebox").TLiteral<"delete">;
-    path: import("../typebox").TString;
-}>;
-export type Edit = Static<typeof Edit>;
-export declare const Edit: import("../typebox").TUnion<[import("../typebox").TObject<{
-    type: import("../typebox").TLiteral<"insert">;
-    path: import("../typebox").TString;
-    value: import("../typebox").TUnknown;
-}>, import("../typebox").TObject<{
-    type: import("../typebox").TLiteral<"update">;
-    path: import("../typebox").TString;
-    value: import("../typebox").TUnknown;
-}>, import("../typebox").TObject<{
-    type: import("../typebox").TLiteral<"delete">;
-    path: import("../typebox").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/index.d.ts

@@ -1,5 +0,0 @@
-export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index';
-export { Edit, Insert, Update, Delete } from './delta';
-export { Mutable } from './mutate';
-export { ValuePointer } from './pointer';
-export { Value } from './value';

package/value/pointer.d.ts

@@ -1,24 +0,0 @@
-export declare class ValuePointerRootSetError extends Error {
-    readonly value: unknown;
-    readonly path: string;
-    readonly update: unknown;
-    constructor(value: unknown, path: string, update: unknown);
-}
-export declare class ValuePointerRootDeleteError extends Error {
-    readonly value: unknown;
-    readonly path: string;
-    constructor(value: unknown, path: string);
-}
-/** Provides functionality to update values through RFC6901 string pointers */
-export declare namespace ValuePointer {
-    /** Formats the given pointer into navigable key components */
-    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 */
-    function Set(value: any, pointer: string, update: unknown): void;
-    /** Deletes a value at the given pointer */
-    function Delete(value: any, pointer: string): void;
-    /** Returns 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,148 +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.ValuePointer = exports.ValuePointerRootDeleteError = exports.ValuePointerRootSetError = void 0;
-// --------------------------------------------------------------------------
-// Errors
-// --------------------------------------------------------------------------
-class ValuePointerRootSetError extends Error {
-    constructor(value, path, update) {
-        super('Cannot set root value');
-        this.value = value;
-        this.path = path;
-        this.update = update;
-    }
-}
-exports.ValuePointerRootSetError = ValuePointerRootSetError;
-class ValuePointerRootDeleteError extends Error {
-    constructor(value, path) {
-        super('Cannot delete root value');
-        this.value = value;
-        this.path = path;
-    }
-}
-exports.ValuePointerRootDeleteError = ValuePointerRootDeleteError;
-// --------------------------------------------------------------------------
-// ValuePointer
-// --------------------------------------------------------------------------
-/** Provides functionality to update values through RFC6901 string pointers */
-var ValuePointer;
-(function (ValuePointer) {
-    function Escape(component) {
-        return component.indexOf('~') === -1 ? component : component.replace(/~1/g, '/').replace(/~0/g, '~');
-    }
-    /** Formats the given pointer into navigable key components */
-    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));
-    }
-    ValuePointer.Format = Format;
-    /** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
-    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;
-    }
-    ValuePointer.Set = Set;
-    /** Deletes a value at the given pointer */
-    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];
-        }
-    }
-    ValuePointer.Delete = Delete;
-    /** Returns true if a value exists at the given pointer */
-    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);
-    }
-    ValuePointer.Has = Has;
-    /** Gets the value at the given pointer */
-    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;
-    }
-    ValuePointer.Get = Get;
-})(ValuePointer || (exports.ValuePointer = ValuePointer = {}));

package/value/transform.d.ts

@@ -1,37 +0,0 @@
-import { ValueError } from '../errors/errors';
-import * as Types from '../typebox';
-export declare class TransformDecodeCheckError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    readonly value: unknown;
-    readonly error: ValueError;
-    constructor(schema: Types.TSchema, value: unknown, error: ValueError);
-}
-export declare class TransformEncodeCheckError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    readonly value: unknown;
-    readonly error: ValueError;
-    constructor(schema: Types.TSchema, value: unknown, error: ValueError);
-}
-export declare class TransformDecodeError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    readonly value: unknown;
-    constructor(schema: Types.TSchema, value: unknown, error: any);
-}
-export declare class TransformEncodeError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    readonly value: unknown;
-    constructor(schema: Types.TSchema, value: unknown, error: any);
-}
-/** Recursively checks a schema for transform codecs */
-export declare namespace HasTransform {
-    /** Returns true if this schema contains a transform codec */
-    function Has(schema: Types.TSchema, references: Types.TSchema[]): boolean;
-}
-/** Decodes a value using transform decoders if available. Does not ensure correct results. */
-export declare namespace DecodeTransform {
-    function Decode(schema: Types.TSchema, references: Types.TSchema[], value: unknown): unknown;
-}
-/** Encodes a value using transform encoders if available. Does not ensure correct results. */
-export declare namespace EncodeTransform {
-    function Encode(schema: Types.TSchema, references: Types.TSchema[], value: unknown): unknown;
-}