@sinclair/typebox 0.31.27 → 0.32.0-dev-1

package/value/transform/has.js

@@ -0,0 +1,146 @@
+"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.HasTransform = void 0;
+const type_1 = require("../../type/guard/type");
+const index_1 = require("../guard/index");
+const index_2 = require("../deref/index");
+const index_3 = require("../../type/symbols/index");
+// prettier-ignore
+function TArray(schema, references) {
+    return (0, type_1.TTransform)(schema) || Visit(schema.items, references);
+}
+// prettier-ignore
+function TAsyncIterator(schema, references) {
+    return (0, type_1.TTransform)(schema) || Visit(schema.items, references);
+}
+// prettier-ignore
+function TConstructor(schema, references) {
+    return (0, type_1.TTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
+}
+// prettier-ignore
+function TFunction(schema, references) {
+    return (0, type_1.TTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
+}
+// prettier-ignore
+function TIntersect(schema, references) {
+    return (0, type_1.TTransform)(schema) || (0, type_1.TTransform)(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references));
+}
+// prettier-ignore
+function TIterator(schema, references) {
+    return (0, type_1.TTransform)(schema) || Visit(schema.items, references);
+}
+// prettier-ignore
+function TNot(schema, references) {
+    return (0, type_1.TTransform)(schema) || Visit(schema.not, references);
+}
+// prettier-ignore
+function TObject(schema, references) {
+    return ((0, type_1.TTransform)(schema) ||
+        Object.values(schema.properties).some((schema) => Visit(schema, references)) ||
+        ((0, type_1.TSchema)(schema.additionalProperties) && Visit(schema.additionalProperties, references)));
+}
+// prettier-ignore
+function TPromise(schema, references) {
+    return (0, type_1.TTransform)(schema) || Visit(schema.item, references);
+}
+// prettier-ignore
+function TRecord(schema, references) {
+    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+    const property = schema.patternProperties[pattern];
+    return (0, type_1.TTransform)(schema) || Visit(property, references) || ((0, type_1.TSchema)(schema.additionalProperties) && (0, type_1.TTransform)(schema.additionalProperties));
+}
+// prettier-ignore
+function TRef(schema, references) {
+    if ((0, type_1.TTransform)(schema))
+        return true;
+    return Visit((0, index_2.Deref)(schema, references), references);
+}
+// prettier-ignore
+function TThis(schema, references) {
+    if ((0, type_1.TTransform)(schema))
+        return true;
+    return Visit((0, index_2.Deref)(schema, references), references);
+}
+// prettier-ignore
+function TTuple(schema, references) {
+    return (0, type_1.TTransform)(schema) || (!(0, index_1.IsUndefined)(schema.items) && schema.items.some((schema) => Visit(schema, references)));
+}
+// prettier-ignore
+function TUnion(schema, references) {
+    return (0, type_1.TTransform)(schema) || schema.anyOf.some((schema) => Visit(schema, references));
+}
+// prettier-ignore
+function Visit(schema, references) {
+    const references_ = (0, index_1.IsString)(schema.$id) ? [...references, schema] : references;
+    const schema_ = schema;
+    if (schema.$id && visited.has(schema.$id))
+        return false;
+    if (schema.$id)
+        visited.add(schema.$id);
+    switch (schema[index_3.Kind]) {
+        case 'Array':
+            return TArray(schema_, references_);
+        case 'AsyncIterator':
+            return TAsyncIterator(schema_, references_);
+        case 'Constructor':
+            return TConstructor(schema_, references_);
+        case 'Function':
+            return TFunction(schema_, references_);
+        case 'Intersect':
+            return TIntersect(schema_, references_);
+        case 'Iterator':
+            return TIterator(schema_, references_);
+        case 'Not':
+            return TNot(schema_, references_);
+        case 'Object':
+            return TObject(schema_, references_);
+        case 'Promise':
+            return TPromise(schema_, references_);
+        case 'Record':
+            return TRecord(schema_, references_);
+        case 'Ref':
+            return TRef(schema_, references_);
+        case 'This':
+            return TThis(schema_, references_);
+        case 'Tuple':
+            return TTuple(schema_, references_);
+        case 'Union':
+            return TUnion(schema_, references_);
+        default:
+            return (0, type_1.TTransform)(schema);
+    }
+}
+const visited = new Set();
+/** Returns true if this schema contains a transform codec */
+function HasTransform(schema, references) {
+    visited.clear();
+    return Visit(schema, references);
+}
+exports.HasTransform = HasTransform;

package/value/transform/index.d.ts

@@ -0,0 +1,3 @@
+export * from './decode';
+export * from './encode';
+export * from './has';

package/value/transform/index.js

@@ -0,0 +1,46 @@
+"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.
+
+---------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./decode"), exports);
+__exportStar(require("./encode"), exports);
+__exportStar(require("./has"), exports);

package/value/value/index.d.ts

@@ -0,0 +1 @@
+export * as Value from './value';

package/value/value/index.js

@@ -0,0 +1,31 @@
+"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.Value = void 0;
+exports.Value = require("./value");

package/value/value/value.d.ts

@@ -0,0 +1,53 @@
+import { type Mutable } from '../mutate/index';
+import { Edit } from '../delta/index';
+import { ValueErrorIterator } from '../../errors/index';
+import type { TSchema } from '../../type/schema/index';
+import type { Static, StaticDecode, StaticEncode } from '../../type/static/index';
+/** 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 TSchema>(schema: T, references: TSchema[], value: unknown): 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 TSchema>(schema: T, value: unknown): Static<T>;
+/** Creates a value from the given type and references */
+export declare function Create<T extends TSchema>(schema: T, references: TSchema[]): Static<T>;
+/** Creates a value from the given type */
+export declare function Create<T extends TSchema>(schema: T): Static<T>;
+/** Returns true if the value matches the given type and references */
+export declare function Check<T extends TSchema>(schema: T, references: TSchema[], value: unknown): value is Static<T>;
+/** Returns true if the value matches the given type */
+export declare function Check<T extends TSchema>(schema: T, value: unknown): value is Static<T>;
+/** `[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. */
+export declare function Clean<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+/** `[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. */
+export declare function Clean<T extends TSchema>(schema: T, value: unknown): unknown;
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible */
+export declare function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+/** Converts any type mismatched values to their target type if a reasonable conversion is possibl. */
+export declare function Convert<T extends TSchema>(schema: T, value: unknown): unknown;
+/** Returns a structural clone of the given value */
+export declare function Clone<T>(value: T): T;
+/** Decodes a value or throws if error */
+export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
+/** Decodes a value or throws if error */
+export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;
+/** `[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. */
+export declare function Default<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+/** `[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. */
+export declare function Default<T extends TSchema>(schema: T, value: unknown): unknown;
+/** Encodes a value or throws if error */
+export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, references: TSchema[], value: unknown): R;
+/** Encodes a value or throws if error */
+export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, value: unknown): R;
+/** Returns an iterator for each error in this value. */
+export declare function Errors<T extends TSchema>(schema: T, references: TSchema[], value: unknown): ValueErrorIterator;
+/** Returns an iterator for each error in this value. */
+export declare function Errors<T extends TSchema>(schema: T, value: unknown): ValueErrorIterator;
+/** Returns true if left and right values are structurally equal */
+export declare function Equal<T>(left: T, right: unknown): right is T;
+/** Returns edits to transform the current value into the next value */
+export declare function Diff(current: unknown, next: unknown): Edit[];
+/** Returns a FNV1A-64 non cryptographic hash of the given value */
+export declare function Hash(value: unknown): bigint;
+/** Returns a new value with edits applied to the given value */
+export declare function Patch<T = any>(current: unknown, edits: Edit[]): T;
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references. */
+export declare function Mutate(current: Mutable, next: Mutable): void;

package/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_1 = require("../transform/index");
+const index_2 = require("../mutate/index");
+const index_3 = require("../hash/index");
+const index_4 = require("../equal/index");
+const index_5 = require("../cast/index");
+const index_6 = require("../clone/index");
+const index_7 = require("../convert/index");
+const index_8 = require("../create/index");
+const index_9 = require("../clean/index");
+const index_10 = require("../check/index");
+const index_11 = require("../default/index");
+const index_12 = require("../delta/index");
+const index_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_5.Cast.apply(index_5.Cast, args);
+}
+exports.Cast = Cast;
+/** Creates a value from the given type */
+function Create(...args) {
+    return index_8.Create.apply(index_8.Create, args);
+}
+exports.Create = Create;
+/** Returns true if the value matches the given type */
+function Check(...args) {
+    return index_10.Check.apply(index_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_9.Clean.apply(index_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_7.Convert.apply(index_7.Convert, args);
+}
+exports.Convert = Convert;
+/** Returns a structural clone of the given value */
+function Clone(value) {
+    return (0, index_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_1.TransformDecodeCheckError(schema, value, Errors(schema, references, value).First());
+    return (0, index_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_11.Default.apply(index_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_1.Encode)(schema, references, value);
+    if (!Check(schema, references, encoded))
+        throw new index_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_13.Errors.apply(index_13.Errors, args);
+}
+exports.Errors = Errors;
+/** Returns true if left and right values are structurally equal */
+function Equal(left, right) {
+    return (0, index_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_12.Diff)(current, next);
+}
+exports.Diff = Diff;
+/** Returns a FNV1A-64 non cryptographic hash of the given value */
+function Hash(value) {
+    return (0, index_3.Hash)(value);
+}
+exports.Hash = Hash;
+/** Returns a new value with edits applied to the given value */
+function Patch(current, edits) {
+    return (0, index_12.Patch)(current, edits);
+}
+exports.Patch = Patch;
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references. */
+function Mutate(current, next) {
+    (0, index_2.Mutate)(current, next);
+}
+exports.Mutate = Mutate;