@sinclair/typebox 0.32.0-dev-3 → 0.32.0-dev-5

package/esm/value/transform/has.mjs

@@ -1,142 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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.mjs

@@ -1,30 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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.mjs

@@ -1,28 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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

@@ -1,53 +0,0 @@
-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

@@ -1,107 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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);
-}