@sinclair/typebox 0.30.3 → 0.31.0-dev-1

package/value/hash.js

@@ -1,7 +1,7 @@
 "use strict";
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox/hash
+@sinclair/typebox/value
 
 The MIT License (MIT)
 
@@ -28,13 +28,13 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Hash = exports.ByteMarker = exports.ValueHashError = void 0;
-const ValueGuard = require("./guard");
+const guard_1 = require("./guard");
 // --------------------------------------------------------------------------
 // Errors
 // --------------------------------------------------------------------------
 class ValueHashError extends Error {
     constructor(value) {
-        super(`Hash: Unable to hash value`);
+        super(`Unable to hash value`);
         this.value = value;
     }
 }
@@ -126,27 +126,27 @@ function UndefinedType(value) {
     return FNV1A64(ByteMarker.Undefined);
 }
 function Visit(value) {
-    if (ValueGuard.IsArray(value))
+    if ((0, guard_1.IsArray)(value))
         return ArrayType(value);
-    if (ValueGuard.IsBoolean(value))
+    if ((0, guard_1.IsBoolean)(value))
         return BooleanType(value);
-    if (ValueGuard.IsBigInt(value))
+    if ((0, guard_1.IsBigInt)(value))
         return BigIntType(value);
-    if (ValueGuard.IsDate(value))
+    if ((0, guard_1.IsDate)(value))
         return DateType(value);
-    if (ValueGuard.IsNull(value))
+    if ((0, guard_1.IsNull)(value))
         return NullType(value);
-    if (ValueGuard.IsNumber(value))
+    if ((0, guard_1.IsNumber)(value))
         return NumberType(value);
-    if (ValueGuard.IsPlainObject(value))
+    if ((0, guard_1.IsPlainObject)(value))
         return ObjectType(value);
-    if (ValueGuard.IsString(value))
+    if ((0, guard_1.IsString)(value))
         return StringType(value);
-    if (ValueGuard.IsSymbol(value))
+    if ((0, guard_1.IsSymbol)(value))
         return SymbolType(value);
-    if (ValueGuard.IsUint8Array(value))
+    if ((0, guard_1.IsUint8Array)(value))
         return Uint8ArrayType(value);
-    if (ValueGuard.IsUndefined(value))
+    if ((0, guard_1.IsUndefined)(value))
         return UndefinedType(value);
     throw new ValueHashError(value);
 }

package/value/mutate.js

@@ -28,27 +28,27 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mutate = exports.ValueMutateInvalidRootMutationError = exports.ValueMutateTypeMismatchError = void 0;
+const guard_1 = require("./guard");
 const pointer_1 = require("./pointer");
-const ValueClone = require("./clone");
-const ValueGuard = require("./guard");
+const clone_1 = require("./clone");
 // --------------------------------------------------------------------------
 // Errors
 // --------------------------------------------------------------------------
 class ValueMutateTypeMismatchError extends Error {
     constructor() {
-        super('ValueMutate: Cannot assign due type mismatch of assignable values');
+        super('Cannot assign due type mismatch of assignable values');
     }
 }
 exports.ValueMutateTypeMismatchError = ValueMutateTypeMismatchError;
 class ValueMutateInvalidRootMutationError extends Error {
     constructor() {
-        super('ValueMutate: Only object and array types can be mutated at the root level');
+        super('Only object and array types can be mutated at the root level');
     }
 }
 exports.ValueMutateInvalidRootMutationError = ValueMutateInvalidRootMutationError;
 function ObjectType(root, path, current, next) {
-    if (!ValueGuard.IsPlainObject(current)) {
-        pointer_1.ValuePointer.Set(root, path, ValueClone.Clone(next));
+    if (!(0, guard_1.IsPlainObject)(current)) {
+        pointer_1.ValuePointer.Set(root, path, (0, clone_1.Clone)(next));
     }
     else {
         const currentKeys = Object.keys(current);
@@ -69,8 +69,8 @@ function ObjectType(root, path, current, next) {
     }
 }
 function ArrayType(root, path, current, next) {
-    if (!ValueGuard.IsArray(current)) {
-        pointer_1.ValuePointer.Set(root, path, ValueClone.Clone(next));
+    if (!(0, guard_1.IsArray)(current)) {
+        pointer_1.ValuePointer.Set(root, path, (0, clone_1.Clone)(next));
     }
     else {
         for (let index = 0; index < next.length; index++) {
@@ -80,13 +80,13 @@ function ArrayType(root, path, current, next) {
     }
 }
 function TypedArrayType(root, path, current, next) {
-    if (ValueGuard.IsTypedArray(current) && current.length === next.length) {
+    if ((0, guard_1.IsTypedArray)(current) && current.length === next.length) {
         for (let i = 0; i < current.length; i++) {
             current[i] = next[i];
         }
     }
     else {
-        pointer_1.ValuePointer.Set(root, path, ValueClone.Clone(next));
+        pointer_1.ValuePointer.Set(root, path, (0, clone_1.Clone)(next));
     }
 }
 function ValueType(root, path, current, next) {
@@ -95,25 +95,25 @@ function ValueType(root, path, current, next) {
     pointer_1.ValuePointer.Set(root, path, next);
 }
 function Visit(root, path, current, next) {
-    if (ValueGuard.IsArray(next))
+    if ((0, guard_1.IsArray)(next))
         return ArrayType(root, path, current, next);
-    if (ValueGuard.IsTypedArray(next))
+    if ((0, guard_1.IsTypedArray)(next))
         return TypedArrayType(root, path, current, next);
-    if (ValueGuard.IsPlainObject(next))
+    if ((0, guard_1.IsPlainObject)(next))
         return ObjectType(root, path, current, next);
-    if (ValueGuard.IsValueType(next))
+    if ((0, guard_1.IsValueType)(next))
         return ValueType(root, path, current, next);
 }
 // --------------------------------------------------------------------------
 // Mutate
 // --------------------------------------------------------------------------
 function IsNonMutableValue(value) {
-    return ValueGuard.IsTypedArray(value) || ValueGuard.IsValueType(value);
+    return (0, guard_1.IsTypedArray)(value) || (0, guard_1.IsValueType)(value);
 }
 function IsMismatchedValue(current, next) {
     // prettier-ignore
-    return ((ValueGuard.IsPlainObject(current) && ValueGuard.IsArray(next)) ||
-        (ValueGuard.IsArray(current) && ValueGuard.IsPlainObject(next)));
+    return (((0, guard_1.IsPlainObject)(current) && (0, guard_1.IsArray)(next)) ||
+        ((0, guard_1.IsArray)(current) && (0, guard_1.IsPlainObject)(next)));
 }
 // --------------------------------------------------------------------------
 // Mutate

package/value/pointer.js

@@ -33,7 +33,7 @@ exports.ValuePointer = exports.ValuePointerRootDeleteError = exports.ValuePointe
 // --------------------------------------------------------------------------
 class ValuePointerRootSetError extends Error {
     constructor(value, path, update) {
-        super('ValuePointer: Cannot set root value');
+        super('Cannot set root value');
         this.value = value;
         this.path = path;
         this.update = update;
@@ -42,7 +42,7 @@ class ValuePointerRootSetError extends Error {
 exports.ValuePointerRootSetError = ValuePointerRootSetError;
 class ValuePointerRootDeleteError extends Error {
     constructor(value, path) {
-        super('ValuePointer: Cannot delete root value');
+        super('Cannot delete root value');
         this.value = value;
         this.path = path;
     }

package/value/transform.d.ts

@@ -0,0 +1,42 @@
+import { ValueError } from '../errors/errors';
+import * as Types from '../typebox';
+export type CheckFunction = (schema: Types.TSchema, references: Types.TSchema[], value: unknown) => boolean;
+export declare class TransformUnknownTypeError extends Types.TypeBoxError {
+    readonly schema: Types.TRef | Types.TThis;
+    constructor(schema: Types.TRef | Types.TThis);
+}
+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, check: CheckFunction): 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, check: CheckFunction): unknown;
+}