@sinclair/typebox 0.31.28 → 0.32.0-dev-2

package/esm/value/transform/has.mjs

@@ -0,0 +1,142 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
+import { TTransform as IsTransformType, TSchema as IsSchemaType } from '../../type/guard/type.mjs';
+import { IsString, IsUndefined } from '../guard/index.mjs';
+import { Deref } from '../deref/index.mjs';
+import { Kind } from '../../type/symbols/index.mjs';
+// prettier-ignore
+function TArray(schema, references) {
+    return IsTransformType(schema) || Visit(schema.items, references);
+}
+// prettier-ignore
+function TAsyncIterator(schema, references) {
+    return IsTransformType(schema) || Visit(schema.items, references);
+}
+// prettier-ignore
+function TConstructor(schema, references) {
+    return IsTransformType(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
+}
+// prettier-ignore
+function TFunction(schema, references) {
+    return IsTransformType(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
+}
+// prettier-ignore
+function TIntersect(schema, references) {
+    return IsTransformType(schema) || IsTransformType(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references));
+}
+// prettier-ignore
+function TIterator(schema, references) {
+    return IsTransformType(schema) || Visit(schema.items, references);
+}
+// prettier-ignore
+function TNot(schema, references) {
+    return IsTransformType(schema) || Visit(schema.not, references);
+}
+// prettier-ignore
+function TObject(schema, references) {
+    return (IsTransformType(schema) ||
+        Object.values(schema.properties).some((schema) => Visit(schema, references)) ||
+        (IsSchemaType(schema.additionalProperties) && Visit(schema.additionalProperties, references)));
+}
+// prettier-ignore
+function TPromise(schema, references) {
+    return IsTransformType(schema) || Visit(schema.item, references);
+}
+// prettier-ignore
+function TRecord(schema, references) {
+    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+    const property = schema.patternProperties[pattern];
+    return IsTransformType(schema) || Visit(property, references) || (IsSchemaType(schema.additionalProperties) && IsTransformType(schema.additionalProperties));
+}
+// prettier-ignore
+function TRef(schema, references) {
+    if (IsTransformType(schema))
+        return true;
+    return Visit(Deref(schema, references), references);
+}
+// prettier-ignore
+function TThis(schema, references) {
+    if (IsTransformType(schema))
+        return true;
+    return Visit(Deref(schema, references), references);
+}
+// prettier-ignore
+function TTuple(schema, references) {
+    return IsTransformType(schema) || (!IsUndefined(schema.items) && schema.items.some((schema) => Visit(schema, references)));
+}
+// prettier-ignore
+function TUnion(schema, references) {
+    return IsTransformType(schema) || schema.anyOf.some((schema) => Visit(schema, references));
+}
+// prettier-ignore
+function Visit(schema, references) {
+    const references_ = 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[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 IsTransformType(schema);
+    }
+}
+const visited = new Set();
+/** Returns true if this schema contains a transform codec */
+export function HasTransform(schema, references) {
+    visited.clear();
+    return Visit(schema, references);
+}

package/esm/value/transform/index.d.mts

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

package/esm/value/transform/index.mjs

@@ -0,0 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
+export * from './decode.mjs';
+export * from './encode.mjs';
+export * from './has.mjs';

package/esm/value/value/index.d.mts

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

package/esm/value/value/index.mjs

@@ -0,0 +1,28 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
+export * as Value from './value.mjs';

package/esm/value/value/value.d.mts

@@ -0,0 +1,53 @@
+import { type Mutable } from '../mutate/index.mjs';
+import { Edit } from '../delta/index.mjs';
+import { ValueErrorIterator } from '../../errors/index.mjs';
+import type { TSchema } from '../../type/schema/index.mjs';
+import type { Static, StaticDecode, StaticEncode } from '../../type/static/index.mjs';
+/** 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/esm/value/value/value.mjs

@@ -0,0 +1,107 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
+import { Decode as DecodeValue, Encode as EncodeValue, TransformDecodeCheckError, TransformEncodeCheckError } from '../transform/index.mjs';
+import { Mutate as MutateValue } from '../mutate/index.mjs';
+import { Hash as HashValue } from '../hash/index.mjs';
+import { Equal as EqualValue } from '../equal/index.mjs';
+import { Cast as CastValue } from '../cast/index.mjs';
+import { Clone as CloneValue } from '../clone/index.mjs';
+import { Convert as ConvertValue } from '../convert/index.mjs';
+import { Create as CreateValue } from '../create/index.mjs';
+import { Clean as CleanValue } from '../clean/index.mjs';
+import { Check as CheckValue } from '../check/index.mjs';
+import { Default as DefaultValue } from '../default/index.mjs';
+import { Diff as DiffValue, Patch as PatchValue } from '../delta/index.mjs';
+import { Errors as ValueErrors } from '../../errors/index.mjs';
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
+export function Cast(...args) {
+    return CastValue.apply(CastValue, args);
+}
+/** Creates a value from the given type */
+export function Create(...args) {
+    return CreateValue.apply(CreateValue, args);
+}
+/** Returns true if the value matches the given type */
+export function Check(...args) {
+    return CheckValue.apply(CheckValue, args);
+}
+/** `[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 function Clean(...args) {
+    return CleanValue.apply(CleanValue, args);
+}
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible */
+export function Convert(...args) {
+    return ConvertValue.apply(ConvertValue, args);
+}
+/** Returns a structural clone of the given value */
+export function Clone(value) {
+    return CloneValue(value);
+}
+/** Decodes a value or throws if error */
+export 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 TransformDecodeCheckError(schema, value, Errors(schema, references, value).First());
+    return DecodeValue(schema, references, value);
+}
+/** `[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 function Default(...args) {
+    return DefaultValue.apply(DefaultValue, args);
+}
+/** Encodes a value or throws if error */
+export function Encode(...args) {
+    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+    const encoded = EncodeValue(schema, references, value);
+    if (!Check(schema, references, encoded))
+        throw new TransformEncodeCheckError(schema, value, Errors(schema, references, value).First());
+    return encoded;
+}
+/** Returns an iterator for each error in this value. */
+export function Errors(...args) {
+    return ValueErrors.apply(ValueErrors, args);
+}
+/** Returns true if left and right values are structurally equal */
+export function Equal(left, right) {
+    return EqualValue(left, right);
+}
+/** Returns edits to transform the current value into the next value */
+export function Diff(current, next) {
+    return DiffValue(current, next);
+}
+/** Returns a FNV1A-64 non cryptographic hash of the given value */
+export function Hash(value) {
+    return HashValue(value);
+}
+/** Returns a new value with edits applied to the given value */
+export function Patch(current, edits) {
+    return PatchValue(current, edits);
+}
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references. */
+export function Mutate(current, next) {
+    MutateValue(current, next);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.28",
+  "version": "0.32.0-dev-2",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -10,55 +10,65 @@
   ],
   "author": "sinclairzx81",
   "license": "MIT",
-  "main": "./typebox.js",
-  "types": "./typebox.d.ts",
+  "main": "./cjs/index.js",
+  "module": "./esm/index.mjs",
+  "types": "./esm/index.d.mts",
   "exports": {
-    "./compiler": "./compiler/index.js",
-    "./errors": "./errors/index.js",
-    "./system": "./system/index.js",
-    "./value/cast": "./value/cast.js",
-    "./value/check": "./value/check.js",
-    "./value/clone": "./value/clone.js",
-    "./value/convert": "./value/convert.js",
-    "./value/create": "./value/create.js",
-    "./value/delta": "./value/delta.js",
-    "./value/deref": "./value/deref.js",
-    "./value/equal": "./value/equal.js",
-    "./value/guard": "./value/guard.js",
-    "./value/hash": "./value/hash.js",
-    "./value/mutate": "./value/mutate.js",
-    "./value/pointer": "./value/pointer.js",
-    "./value/transform": "./value/transform.js",
-    "./value": "./value/index.js",
-    ".": "./typebox.js"
+    "./compiler": {
+      "require": "./cjs/compiler/index.js",
+      "import": "./esm/compiler/index.mjs"
+    },
+    "./errors": {
+      "require": "./cjs/errors/index.js",
+      "import": "./esm/errors/index.mjs"
+    },
+    "./system": {
+      "require": "./cjs/system/index.js",
+      "import": "./esm/system/index.mjs"
+    },
+    "./type": {
+      "require": "./cjs/type/index.js",
+      "import": "./esm/type/index.mjs"
+    },
+    "./value": {
+      "require": "./cjs/value/index.js",
+      "import": "./esm/value/index.mjs"
+    },
+    ".": {
+      "require": "./cjs/index.js",
+      "import": "./esm/index.mjs"
+    }
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/sinclairzx81/typebox"
   },
   "scripts": {
+    "benchmark:compression": "hammer task benchmark_compression",
+    "benchmark:measurement": "hammer task benchmark_measurement",
+    "benchmark": "hammer task benchmark",
+    "install:local": "hammer task install_local",
     "test:typescript": "hammer task test_typescript",
     "test:static": "hammer task test_static",
     "test:runtime": "hammer task test_runtime",
+    "build:esm": "hammer task build_esm",
+    "build:cjs": "hammer task build_cjs",
+    "build": "hammer task build",
     "test": "hammer task test",
     "clean": "hammer task clean",
     "format": "hammer task format",
     "start": "hammer task start",
-    "benchmark:compression": "hammer task benchmark_compression",
-    "benchmark:measurement": "hammer task benchmark_measurement",
-    "benchmark": "hammer task benchmark",
-    "build": "hammer task build",
     "publish": "hammer task publish",
     "publish:dev": "hammer task publish_dev"
   },
   "devDependencies": {
     "@sinclair/hammer": "^0.18.0",
     "@types/mocha": "^9.1.1",
-    "@types/node": "^18.11.9",
+    "@types/node": "^20.10.1",
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^5.2.2"
+    "typescript": "^5.3.2"
   }
 }