@sinclair/typebox 0.31.28 → 0.32.0-dev-2

package/cjs/value/value/value.js

@@ -0,0 +1,125 @@
+"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.Mutate = exports.Patch = exports.Hash = exports.Diff = exports.Equal = exports.Errors = exports.Encode = exports.Default = exports.Decode = exports.Clone = exports.Convert = exports.Clean = exports.Check = exports.Create = exports.Cast = void 0;
+const index_mjs_1 = require("../transform/index");
+const index_mjs_2 = require("../mutate/index");
+const index_mjs_3 = require("../hash/index");
+const index_mjs_4 = require("../equal/index");
+const index_mjs_5 = require("../cast/index");
+const index_mjs_6 = require("../clone/index");
+const index_mjs_7 = require("../convert/index");
+const index_mjs_8 = require("../create/index");
+const index_mjs_9 = require("../clean/index");
+const index_mjs_10 = require("../check/index");
+const index_mjs_11 = require("../default/index");
+const index_mjs_12 = require("../delta/index");
+const index_mjs_13 = require("../../errors/index");
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
+function Cast(...args) {
+    return index_mjs_5.Cast.apply(index_mjs_5.Cast, args);
+}
+exports.Cast = Cast;
+/** Creates a value from the given type */
+function Create(...args) {
+    return index_mjs_8.Create.apply(index_mjs_8.Create, args);
+}
+exports.Create = Create;
+/** Returns true if the value matches the given type */
+function Check(...args) {
+    return index_mjs_10.Check.apply(index_mjs_10.Check, args);
+}
+exports.Check = Check;
+/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
+function Clean(...args) {
+    return index_mjs_9.Clean.apply(index_mjs_9.Clean, args);
+}
+exports.Clean = Clean;
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible */
+function Convert(...args) {
+    return index_mjs_7.Convert.apply(index_mjs_7.Convert, args);
+}
+exports.Convert = Convert;
+/** Returns a structural clone of the given value */
+function Clone(value) {
+    return (0, index_mjs_6.Clone)(value);
+}
+exports.Clone = Clone;
+/** Decodes a value or throws if error */
+function Decode(...args) {
+    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+    if (!Check(schema, references, value))
+        throw new index_mjs_1.TransformDecodeCheckError(schema, value, Errors(schema, references, value).First());
+    return (0, index_mjs_1.Decode)(schema, references, value);
+}
+exports.Decode = Decode;
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
+function Default(...args) {
+    return index_mjs_11.Default.apply(index_mjs_11.Default, args);
+}
+exports.Default = Default;
+/** Encodes a value or throws if error */
+function Encode(...args) {
+    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+    const encoded = (0, index_mjs_1.Encode)(schema, references, value);
+    if (!Check(schema, references, encoded))
+        throw new index_mjs_1.TransformEncodeCheckError(schema, value, Errors(schema, references, value).First());
+    return encoded;
+}
+exports.Encode = Encode;
+/** Returns an iterator for each error in this value. */
+function Errors(...args) {
+    return index_mjs_13.Errors.apply(index_mjs_13.Errors, args);
+}
+exports.Errors = Errors;
+/** Returns true if left and right values are structurally equal */
+function Equal(left, right) {
+    return (0, index_mjs_4.Equal)(left, right);
+}
+exports.Equal = Equal;
+/** Returns edits to transform the current value into the next value */
+function Diff(current, next) {
+    return (0, index_mjs_12.Diff)(current, next);
+}
+exports.Diff = Diff;
+/** Returns a FNV1A-64 non cryptographic hash of the given value */
+function Hash(value) {
+    return (0, index_mjs_3.Hash)(value);
+}
+exports.Hash = Hash;
+/** Returns a new value with edits applied to the given value */
+function Patch(current, edits) {
+    return (0, index_mjs_12.Patch)(current, edits);
+}
+exports.Patch = Patch;
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references. */
+function Mutate(current, next) {
+    (0, index_mjs_2.Mutate)(current, next);
+}
+exports.Mutate = Mutate;

package/{compiler/compiler.d.ts → esm/compiler/compiler.d.mts}

@@ -1,31 +1,38 @@
-import { ValueErrorIterator } from '../errors/errors';
-import * as Types from '../typebox';
+import { ValueErrorIterator } from '../errors/index.mjs';
+import type { TSchema } from '../type/schema/index.mjs';
+import type { Static, StaticDecode, StaticEncode } from '../type/static/index.mjs';
 export type CheckFunction = (value: unknown) => boolean;
-export declare class TypeCheck<T extends Types.TSchema> {
+export declare class TypeCheck<T extends TSchema> {
     private readonly schema;
     private readonly references;
     private readonly checkFunc;
     private readonly code;
     private readonly hasTransform;
-    constructor(schema: T, references: Types.TSchema[], checkFunc: CheckFunction, code: string);
+    constructor(schema: T, references: TSchema[], checkFunc: CheckFunction, code: string);
     /** Returns the generated assertion code used to validate this type. */
     Code(): string;
     /** Returns an iterator for each error in this value. */
     Errors(value: unknown): ValueErrorIterator;
     /** Returns true if the value matches the compiled type. */
-    Check(value: unknown): value is Types.Static<T>;
-    /** Decodes a value or throws if error */
-    Decode(value: unknown): Types.StaticDecode<T>;
-    /** Encodes a value or throws if error */
-    Encode(value: unknown): Types.StaticEncode<T>;
+    Check(value: unknown): value is Static<T>;
+    /**
+     * Decodes a value or throws if error
+     * @deprecated Use raw `Decode` from `Value` module
+     */
+    Decode(value: unknown): StaticDecode<T>;
+    /**
+     * Encodes a value or throws if error
+     * @deprecated Use raw `Encode` from `Value` module
+     */
+    Encode(value: unknown): StaticEncode<T>;
 }
-export declare class TypeCompilerUnknownTypeError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
+export declare class TypeCompilerUnknownTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
 }
-export declare class TypeCompilerTypeGuardError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
+export declare class TypeCompilerTypeGuardError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
 }
 export declare namespace Policy {
     function IsExactOptionalProperty(value: string, key: string, expression: string): string;
@@ -41,9 +48,9 @@ export interface TypeCompilerCodegenOptions {
 /** Compiles Types for Runtime Type Checking */
 export declare namespace TypeCompiler {
     /** Generates the code used to assert this type and returns it as a string */
-    function Code<T extends Types.TSchema>(schema: T, references: Types.TSchema[], options?: TypeCompilerCodegenOptions): string;
+    function Code<T extends TSchema>(schema: T, references: TSchema[], options?: TypeCompilerCodegenOptions): string;
     /** Generates the code used to assert this type and returns it as a string */
-    function Code<T extends Types.TSchema>(schema: T, options?: TypeCompilerCodegenOptions): string;
+    function Code<T extends TSchema>(schema: T, options?: TypeCompilerCodegenOptions): string;
     /** Compiles a TypeBox type for optimal runtime type checking. Types must be valid TypeBox types of TSchema */
-    function Compile<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): TypeCheck<T>;
+    function Compile<T extends TSchema>(schema: T, references?: TSchema[]): TypeCheck<T>;
 }