@sinclair/typebox 0.29.6 → 0.30.0-dev-2

package/value/clone.d.ts

@@ -1,3 +1,2 @@
-export declare namespace ValueClone {
-    function Clone<T extends unknown>(value: T): T;
-}
+/** Returns a clone of the given value */
+export declare function Clone<T extends unknown>(value: T): T;

package/value/clone.js

@@ -27,45 +27,65 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueClone = void 0;
-const is_1 = require("./is");
-var ValueClone;
-(function (ValueClone) {
-    function Array(value) {
-        return value.map((element) => Clone(element));
-    }
-    function Date(value) {
-        return new globalThis.Date(value.toISOString());
-    }
-    function Object(value) {
-        const keys = [...globalThis.Object.keys(value), ...globalThis.Object.getOwnPropertySymbols(value)];
-        return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {});
-    }
-    function TypedArray(value) {
-        return value.slice();
-    }
-    function Value(value) {
-        return value;
-    }
-    function Clone(value) {
-        if (is_1.Is.Date(value)) {
-            return Date(value);
-        }
-        else if (is_1.Is.Object(value)) {
-            return Object(value);
-        }
-        else if (is_1.Is.Array(value)) {
-            return Array(value);
-        }
-        else if (is_1.Is.TypedArray(value)) {
-            return TypedArray(value);
-        }
-        else if (is_1.Is.Value(value)) {
-            return Value(value);
-        }
-        else {
-            throw new Error('ValueClone: Unable to clone value');
-        }
-    }
-    ValueClone.Clone = Clone;
-})(ValueClone || (exports.ValueClone = ValueClone = {}));
+exports.Clone = void 0;
+const ValueGuard = require("./guard");
+// --------------------------------------------------------------------------
+// Clonable
+// --------------------------------------------------------------------------
+function ObjectType(value) {
+    const keys = [...Object.getOwnPropertyNames(value), ...Object.getOwnPropertySymbols(value)];
+    return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {});
+}
+function ArrayType(value) {
+    return value.map((element) => Clone(element));
+}
+function TypedArrayType(value) {
+    return value.slice();
+}
+function DateType(value) {
+    return new Date(value.toISOString());
+}
+function ValueType(value) {
+    return value;
+}
+// --------------------------------------------------------------------------
+// Non-Clonable
+// --------------------------------------------------------------------------
+function AsyncIteratorType(value) {
+    return value;
+}
+function IteratorType(value) {
+    return value;
+}
+function FunctionType(value) {
+    return value;
+}
+function PromiseType(value) {
+    return value;
+}
+// --------------------------------------------------------------------------
+// Clone
+// --------------------------------------------------------------------------
+/** Returns a clone of the given value */
+function Clone(value) {
+    if (ValueGuard.IsArray(value))
+        return ArrayType(value);
+    if (ValueGuard.IsAsyncIterator(value))
+        return AsyncIteratorType(value);
+    if (ValueGuard.IsFunction(value))
+        return FunctionType(value);
+    if (ValueGuard.IsIterator(value))
+        return IteratorType(value);
+    if (ValueGuard.IsPromise(value))
+        return PromiseType(value);
+    if (ValueGuard.IsDate(value))
+        return DateType(value);
+    if (ValueGuard.IsPlainObject(value))
+        return ObjectType(value);
+    if (ValueGuard.IsTypedArray(value))
+        return TypedArrayType(value);
+    if (ValueGuard.IsValueType(value))
+        return ValueType(value);
+    throw new Error('ValueClone: Unable to clone value');
+}
+exports.Clone = Clone;

package/value/convert.d.ts

@@ -7,7 +7,7 @@ export declare class ValueConvertDereferenceError extends Error {
     readonly schema: Types.TRef | Types.TThis;
     constructor(schema: Types.TRef | Types.TThis);
 }
-export declare namespace ValueConvert {
-    function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown;
-    function Convert<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): 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, 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;