typebox 0.0.1 → 1.0.0

package/build/value/codec/callback.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsCodec } from '../../type/index.mjs';
+// ------------------------------------------------------------------
+// Decode
+// ------------------------------------------------------------------
+function Decode(context, type, value) {
+    return type['~codec'].decode(value);
+}
+// ------------------------------------------------------------------
+// Encode
+// ------------------------------------------------------------------
+function Encode(context, type, value) {
+    return type['~codec'].encode(value);
+}
+// ------------------------------------------------------------------
+// Callback
+// ------------------------------------------------------------------
+export function Callback(direction, context, type, value) {
+    if (!IsCodec(type))
+        return value;
+    return Guard.IsEqual(direction, 'Decode')
+        ? Decode(context, type, value)
+        : Encode(context, type, value);
+}

package/build/value/codec/decode.d.mts

@@ -0,0 +1,19 @@
+import { type TProperties, type TSchema, type StaticDecode } from '../../type/index.mjs';
+import { AssertError } from '../assert/index.mjs';
+export declare class DecodeError extends AssertError {
+    constructor(value: unknown, errors: object[]);
+}
+/**
+ * Decodes a value against the given type by applying a sequence of Clone,
+ * Default, Convert, and Clone operations, then executing any embedded Decode
+ * callbacks. If the processing sequence fails to produce a value matching the
+ * provided type, a DecodeError is thrown.
+ */
+export declare function Decode<const Type extends TSchema, Result extends unknown = StaticDecode<Type>>(type: Type, value: unknown): Result;
+/**
+ * Decodes a value against the given type by applying a sequence of Clone,
+ * Default, Convert, and Clone operations, then executing any embedded Decode
+ * callbacks. If the processing sequence fails to produce a value matching the
+ * provided type, a DecodeError is thrown.
+ */
+export declare function Decode<Context extends TProperties, const Type extends TSchema, Result extends unknown = StaticDecode<Type, Context>>(context: Context, type: Type, value: unknown): Result;

package/build/value/codec/decode.mjs

@@ -0,0 +1,48 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+import { AssertError } from '../assert/index.mjs';
+import { Check } from '../check/index.mjs';
+import { Errors } from '../errors/index.mjs';
+import { Clean } from '../clean/index.mjs';
+import { Clone } from '../clone/index.mjs';
+import { Convert } from '../convert/index.mjs';
+import { Default } from '../default/index.mjs';
+import { Pipeline } from '../pipeline/index.mjs';
+import { FromType } from './from-type.mjs';
+// ------------------------------------------------------------------
+// Assert
+// ------------------------------------------------------------------
+export class DecodeError extends AssertError {
+    constructor(value, errors) {
+        super('Decode', value, errors);
+    }
+}
+function Assert(context, type, value) {
+    if (!Check(context, type, value))
+        throw new DecodeError(value, Errors(context, type, value));
+    return value;
+}
+// ------------------------------------------------------------------
+// Decoder
+// ------------------------------------------------------------------
+const Decoder = Pipeline([
+    (_context, _type, value) => Clone(value),
+    (context, type, value) => Default(context, type, value),
+    (context, type, value) => Convert(context, type, value),
+    (context, type, value) => Clean(context, type, value),
+    (context, type, value) => Assert(context, type, value),
+    (context, type, value) => FromType('Decode', context, type, value)
+]);
+/**
+ * Decodes a value against the given type by applying a sequence of Clone,
+ * Default, Convert, and Clone operations, then executing any embedded Decode
+ * callbacks. If the processing sequence fails to produce a value matching the
+ * provided type, a DecodeError is thrown.
+ */
+export function Decode(...args) {
+    const [context, type, value] = Arguments.Match(args, {
+        3: (context, type, value) => [context, type, value],
+        2: (type, value) => [{}, type, value],
+    });
+    return Decoder(context, type, value);
+}

package/build/value/codec/encode.d.mts

@@ -0,0 +1,9 @@
+import { type TProperties, type TSchema, type StaticEncode } from '../../type/index.mjs';
+import { AssertError } from '../assert/index.mjs';
+export declare class EncodeError extends AssertError {
+    constructor(value: unknown, errors: object[]);
+}
+/** Encodes a value. */
+export declare function Encode<const Type extends TSchema, Result extends unknown = StaticEncode<Type>>(type: Type, value: unknown): Result;
+/** Encodes a value. */
+export declare function Encode<Context extends TProperties, const Type extends TSchema, Result extends unknown = StaticEncode<Type, Context>>(context: Context, type: Type, value: unknown): Result;

package/build/value/codec/encode.mjs

@@ -0,0 +1,43 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+import { AssertError } from '../assert/index.mjs';
+import { Check } from '../check/index.mjs';
+import { Errors } from '../errors/index.mjs';
+import { Clean } from '../clean/index.mjs';
+import { Clone } from '../clone/index.mjs';
+import { Convert } from '../convert/index.mjs';
+import { Default } from '../default/index.mjs';
+import { Pipeline } from '../pipeline/index.mjs';
+import { FromType } from './from-type.mjs';
+// ------------------------------------------------------------------
+// Assert
+// ------------------------------------------------------------------
+export class EncodeError extends AssertError {
+    constructor(value, errors) {
+        super('Encode', value, errors);
+    }
+}
+function Assert(context, type, value) {
+    if (!Check(context, type, value))
+        throw new EncodeError(value, Errors(context, type, value));
+    return value;
+}
+// ------------------------------------------------------------------
+// Encoder
+// ------------------------------------------------------------------
+const Encoder = Pipeline([
+    (_context, _type, value) => Clone(value),
+    (context, type, value) => FromType('Encode', context, type, value),
+    (context, type, value) => Default(context, type, value),
+    (context, type, value) => Convert(context, type, value),
+    (context, type, value) => Clean(context, type, value),
+    (context, type, value) => Assert(context, type, value),
+]);
+/** Encodes a value. */
+export function Encode(...args) {
+    const [context, type, value] = Arguments.Match(args, {
+        3: (context, type, value) => [context, type, value],
+        2: (type, value) => [{}, type, value],
+    });
+    return Encoder(context, type, value);
+}

package/build/value/codec/from-array.d.mts

@@ -0,0 +1,2 @@
+import { type TArray, type TProperties } from '../../type/index.mjs';
+export declare function FromArray(direction: string, context: TProperties, type: TArray, value: unknown): unknown;

package/build/value/codec/from-array.mjs

@@ -0,0 +1,38 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../../system/unreachable/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+import { Callback } from './callback.mjs';
+// ------------------------------------------------------------------
+// Decode
+// ------------------------------------------------------------------
+function Decode(direction, context, type, value) {
+    // deno-coverage-ignore-start - unreachable | checked
+    if (!Guard.IsArray(value))
+        return Unreachable();
+    // deno-coverage-ignore-stop
+    for (let i = 0; i < value.length; i++) {
+        value[i] = FromType(direction, context, type.items, value[i]);
+    }
+    return Callback(direction, context, type, value);
+}
+// ------------------------------------------------------------------
+// Encode
+// ------------------------------------------------------------------
+function Encode(direction, context, type, value) {
+    const exterior = Callback(direction, context, type, value);
+    if (!Guard.IsArray(exterior))
+        return exterior;
+    for (let i = 0; i < exterior.length; i++) {
+        exterior[i] = FromType(direction, context, type.items, exterior[i]);
+    }
+    return exterior;
+}
+// ------------------------------------------------------------------
+// FromArray
+// ------------------------------------------------------------------
+export function FromArray(direction, context, type, value) {
+    return Guard.IsEqual(direction, 'Decode')
+        ? Decode(direction, context, type, value)
+        : Encode(direction, context, type, value);
+}

package/build/value/codec/from-cyclic.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, type TCyclic } from '../../type/index.mjs';
+export declare function FromCyclic(direction: string, context: TProperties, type: TCyclic, value: unknown): unknown;

package/build/value/codec/from-cyclic.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { Ref } from '../../type/index.mjs';
+import { FromType } from './from-type.mjs';
+import { Callback } from './callback.mjs';
+export function FromCyclic(direction, context, type, value) {
+    value = FromType(direction, { ...context, ...type.$defs }, Ref(type.$ref), value);
+    return Callback(direction, context, type, value);
+}

package/build/value/codec/from-intersect.d.mts

@@ -0,0 +1,2 @@
+import { type TIntersect, type TProperties } from '../../type/index.mjs';
+export declare function FromIntersect(direction: string, context: TProperties, type: TIntersect, value: unknown): unknown;

package/build/value/codec/from-intersect.mjs

@@ -0,0 +1,28 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+import { Callback } from './callback.mjs';
+// ------------------------------------------------------------------
+// Decode
+// ------------------------------------------------------------------
+function Decode(direction, context, type, value) {
+    for (const schema of type.allOf) {
+        value = FromType(direction, context, schema, value);
+    }
+    return Callback(direction, context, type, value);
+}
+// ------------------------------------------------------------------
+// Encode
+// ------------------------------------------------------------------
+function Encode(direction, context, type, value) {
+    let exterior = Callback(direction, context, type, value);
+    for (const schema of type.allOf) {
+        exterior = FromType(direction, context, schema, exterior);
+    }
+    return exterior;
+}
+export function FromIntersect(direction, context, type, value) {
+    return Guard.IsEqual(direction, 'Decode')
+        ? Decode(direction, context, type, value)
+        : Encode(direction, context, type, value);
+}

package/build/value/codec/from-object.d.mts

@@ -0,0 +1,2 @@
+import { type TObject, type TProperties } from '../../type/index.mjs';
+export declare function FromObject(direction: string, context: TProperties, type: TObject, value: unknown): unknown;

package/build/value/codec/from-object.mjs

@@ -0,0 +1,44 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../../system/unreachable/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+import { Callback } from './callback.mjs';
+// ------------------------------------------------------------------
+// Decode
+// ------------------------------------------------------------------
+function Decode(direction, context, type, value) {
+    // deno-coverage-ignore-start - unreachable | checked
+    if (!Guard.IsObjectNotArray(value))
+        return Unreachable();
+    // deno-coverage-ignore-stop
+    for (const key of Guard.Keys(type.properties)) {
+        // deno-coverage-ignore-start - unreachable | checked
+        if (!Guard.HasPropertyKey(value, key))
+            Unreachable();
+        // deno-coverage-ignore-stop
+        value[key] = FromType(direction, context, type.properties[key], value[key]);
+    }
+    return Callback(direction, context, type, value);
+}
+// ------------------------------------------------------------------
+// Encode
+// ------------------------------------------------------------------
+function Encode(direction, context, type, value) {
+    const exterior = Callback(direction, context, type, value);
+    if (!Guard.IsObjectNotArray(exterior))
+        return exterior;
+    for (const key of Guard.Keys(type.properties)) {
+        if (!Guard.HasPropertyKey(exterior, key))
+            continue;
+        exterior[key] = FromType(direction, context, type.properties[key], exterior[key]);
+    }
+    return exterior;
+}
+// ------------------------------------------------------------------
+// FromObject
+// ------------------------------------------------------------------
+export function FromObject(direction, context, type, value) {
+    return Guard.IsEqual(direction, 'Decode')
+        ? Decode(direction, context, type, value)
+        : Encode(direction, context, type, value);
+}

package/build/value/codec/from-record.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, type TRecord } from '../../type/index.mjs';
+export declare function FromRecord(direction: string, context: TProperties, type: TRecord, value: unknown): unknown;

package/build/value/codec/from-record.mjs

@@ -0,0 +1,44 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../../system/unreachable/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { RecordPattern, RecordValue } from '../../type/index.mjs';
+import { FromType } from './from-type.mjs';
+import { Callback } from './callback.mjs';
+// ------------------------------------------------------------------
+// Decode
+// ------------------------------------------------------------------
+function Decode(direction, context, type, value) {
+    // deno-coverage-ignore-start - unreachable | checked
+    if (!Guard.IsObjectNotArray(value))
+        return Unreachable();
+    // deno-coverage-ignore-stop
+    const regexp = new RegExp(RecordPattern(type));
+    for (const key of Guard.Keys(value)) {
+        // deno-coverage-ignore-start - unreachable | checked
+        if (!regexp.test(key))
+            Unreachable();
+        // deno-coverage-ignore-stop
+        value[key] = FromType(direction, context, RecordValue(type), value[key]);
+    }
+    return Callback(direction, context, type, value);
+}
+// ------------------------------------------------------------------
+// Encode
+// ------------------------------------------------------------------
+function Encode(direction, context, type, value) {
+    const exterior = Callback(direction, context, type, value);
+    if (!Guard.IsObjectNotArray(exterior))
+        return exterior;
+    const regexp = new RegExp(RecordPattern(type));
+    for (const key of Guard.Keys(exterior)) {
+        if (!regexp.test(key))
+            continue;
+        exterior[key] = FromType(direction, context, RecordValue(type), exterior[key]);
+    }
+    return exterior;
+}
+export function FromRecord(direction, context, type, value) {
+    return Guard.IsEqual(direction, 'Decode')
+        ? Decode(direction, context, type, value)
+        : Encode(direction, context, type, value);
+}

package/build/value/codec/from-ref.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, type TRef } from '../../type/index.mjs';
+export declare function FromRef(direction: string, context: TProperties, type: TRef, value: unknown): unknown;

package/build/value/codec/from-ref.mjs

@@ -0,0 +1,10 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+import { Callback } from './callback.mjs';
+export function FromRef(direction, context, type, value) {
+    value = Guard.HasPropertyKey(context, type.$ref)
+        ? FromType(direction, context, context[type.$ref], value)
+        : value;
+    return Callback(direction, context, type, value);
+}

package/build/value/codec/from-tuple.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, type TTuple } from '../../type/index.mjs';
+export declare function FromTuple(direction: string, context: TProperties, type: TTuple, value: unknown): unknown;

package/build/value/codec/from-tuple.mjs

@@ -0,0 +1,35 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../../system/unreachable/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+import { Callback } from './callback.mjs';
+// ------------------------------------------------------------------
+// Decode
+// ------------------------------------------------------------------
+function Decode(direction, context, type, value) {
+    // deno-coverage-ignore-start - unreachable | checked
+    if (!Guard.IsArray(value))
+        return Unreachable();
+    // deno-coverage-ignore-stop
+    for (let i = 0; i < Math.min(type.items.length, value.length); i++) {
+        value[i] = FromType(direction, context, type.items[i], value[i]);
+    }
+    return Callback(direction, context, type, value);
+}
+// ------------------------------------------------------------------
+// Encode
+// ------------------------------------------------------------------
+function Encode(direction, context, type, value) {
+    const exterior = Callback(direction, context, type, value);
+    if (!Guard.IsArray(exterior))
+        return value;
+    for (let i = 0; i < Math.min(type.items.length, exterior.length); i++) {
+        exterior[i] = FromType(direction, context, type.items[i], exterior[i]);
+    }
+    return exterior;
+}
+export function FromTuple(direction, context, type, value) {
+    return Guard.IsEqual(direction, 'Decode')
+        ? Decode(direction, context, type, value)
+        : Encode(direction, context, type, value);
+}

package/build/value/codec/from-type.d.mts

@@ -0,0 +1,2 @@
+import * as Type from '../../type/index.mjs';
+export declare function FromType(direction: string, context: Type.TProperties, type: Type.TSchema, value: unknown): unknown;

package/build/value/codec/from-type.mjs

@@ -0,0 +1,22 @@
+// deno-fmt-ignore-file
+import * as Type from '../../type/index.mjs';
+import { FromArray } from './from-array.mjs';
+import { FromCyclic } from './from-cyclic.mjs';
+import { FromIntersect } from './from-intersect.mjs';
+import { FromObject } from './from-object.mjs';
+import { FromRecord } from './from-record.mjs';
+import { FromRef } from './from-ref.mjs';
+import { FromTuple } from './from-tuple.mjs';
+import { FromUnion } from './from-union.mjs';
+import { Callback } from './callback.mjs';
+export function FromType(direction, context, type, value) {
+    return (Type.IsArray(type) ? FromArray(direction, context, type, value) :
+        Type.IsCyclic(type) ? FromCyclic(direction, context, type, value) :
+            Type.IsIntersect(type) ? FromIntersect(direction, context, type, value) :
+                Type.IsObject(type) ? FromObject(direction, context, type, value) :
+                    Type.IsRecord(type) ? FromRecord(direction, context, type, value) :
+                        Type.IsRef(type) ? FromRef(direction, context, type, value) :
+                            Type.IsTuple(type) ? FromTuple(direction, context, type, value) :
+                                Type.IsUnion(type) ? FromUnion(direction, context, type, value) :
+                                    Callback(direction, context, type, value));
+}

package/build/value/codec/from-union.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, type TUnion } from '../../type/index.mjs';
+export declare function FromUnion(direction: string, context: TProperties, type: TUnion, value: unknown): unknown;

package/build/value/codec/from-union.mjs

@@ -0,0 +1,42 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../../system/unreachable/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { Callback } from './callback.mjs';
+import { FromType } from './from-type.mjs';
+import { Clone } from '../clone/index.mjs';
+import { Check } from '../check/index.mjs';
+// ------------------------------------------------------------------
+// Decode
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - unreachable | checked
+function Decode(direction, context, type, value) {
+    for (const schema of type.anyOf) {
+        if (!Check(context, schema, value))
+            continue;
+        const variant = FromType(direction, context, schema, value);
+        return Callback(direction, context, type, variant);
+    }
+    return Unreachable();
+}
+// deno-coverage-ignore-stop
+// ------------------------------------------------------------------
+// Encode
+// ------------------------------------------------------------------
+function Encode(direction, context, type, value) {
+    let exterior = Callback(direction, context, type, value);
+    for (const schema of type.anyOf) {
+        const variant = FromType(direction, context, schema, Clone(exterior));
+        if (!Check(context, schema, variant))
+            continue;
+        return variant;
+    }
+    return exterior;
+}
+// ------------------------------------------------------------------
+// FromUnion
+// ------------------------------------------------------------------
+export function FromUnion(direction, context, type, value) {
+    return Guard.IsEqual(direction, 'Decode')
+        ? Decode(direction, context, type, value)
+        : Encode(direction, context, type, value);
+}

package/build/value/codec/has.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema, type TProperties } from '../../type/index.mjs';
+/** Returns true if this type contains a Codec */
+export declare function HasCodec(context: TProperties, type: TSchema): boolean;
+/** Returns true if this type contains a Codec */
+export declare function HasCodec(type: TSchema): boolean;

package/build/value/codec/has.mjs

@@ -0,0 +1,85 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { IsCodec } from '../../type/index.mjs';
+import { IsArray } from '../../type/index.mjs';
+import { IsCyclic } from '../../type/index.mjs';
+import { IsIntersect } from '../../type/index.mjs';
+import { IsObject } from '../../type/index.mjs';
+import { IsRecord, RecordValue } from '../../type/index.mjs';
+import { IsRef, Ref } from '../../type/index.mjs';
+import { IsTuple } from '../../type/index.mjs';
+import { IsUnion } from '../../type/index.mjs';
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+function FromArray(context, type) {
+    return IsCodec(type) || FromType(context, type.items);
+}
+// ------------------------------------------------------------------
+// Cyclic
+// ------------------------------------------------------------------
+function FromCyclic(context, type) {
+    return IsCodec(type) || FromRef({ ...context, ...type.$defs }, Ref(type.$ref));
+}
+// ------------------------------------------------------------------
+// Intersect
+// ------------------------------------------------------------------
+function FromIntersect(context, type) {
+    return IsCodec(type) || type.allOf.some((type) => FromType(context, type));
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+function FromObject(context, type) {
+    return IsCodec(type) || Guard.Keys(type.properties).some(key => {
+        return FromType(context, type.properties[key]);
+    });
+}
+// ------------------------------------------------------------------
+// Record
+// ------------------------------------------------------------------
+function FromRecord(context, type) {
+    return IsCodec(type) || FromType(context, RecordValue(type));
+}
+// ------------------------------------------------------------------
+// Ref
+// ------------------------------------------------------------------
+function FromRef(context, type) {
+    return IsCodec(type) || (Guard.HasPropertyKey(context, type.$ref)
+        && FromType(context, context[type.$ref]));
+}
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+function FromTuple(context, type) {
+    return IsCodec(type) || type.items.some(type => FromType(context, type));
+}
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+function FromUnion(context, type) {
+    return IsCodec(type) || type.anyOf.some(type => FromType(context, type));
+}
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+function FromType(context, type) {
+    return (IsArray(type) ? FromArray(context, type) :
+        IsCyclic(type) ? FromCyclic(context, type) :
+            IsIntersect(type) ? FromIntersect(context, type) :
+                IsObject(type) ? FromObject(context, type) :
+                    IsRecord(type) ? FromRecord(context, type) :
+                        IsRef(type) ? FromRef(context, type) :
+                            IsTuple(type) ? FromTuple(context, type) :
+                                IsUnion(type) ? FromUnion(context, type) :
+                                    IsCodec(type));
+}
+/** Returns true if this type contains a Codec */
+export function HasCodec(...args) {
+    const [context, type] = Arguments.Match(args, {
+        2: (context, type) => [context, type],
+        1: (type) => [{}, type]
+    });
+    return FromType(context, type);
+}

package/build/value/codec/index.d.mts

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

package/build/value/codec/index.mjs

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

package/build/value/convert/convert.d.mts

@@ -0,0 +1,13 @@
+import type { TProperties, TSchema } from '../../type/index.mjs';
+/**
+ * Converts a value to the given type, coercing interior values if a reasonable conversion is possible. This
+ * function returns unknown so callers should Check the return value before use. This function mutates the
+ * provided value. If mutation is not wanted, you should Clone the value before passing to this function.
+ */
+export declare function Convert(context: TProperties, type: TSchema, value: unknown): unknown;
+/**
+ * Converts a value to the given type, coercing interior values if a reasonable conversion is possible. This
+ * function returns unknown so callers should Check the return value before use. This function mutates the
+ * provided value. If mutation is not wanted, you should Clone the value before passing to this function.
+ */
+export declare function Convert(type: TSchema, value: unknown): unknown;

package/build/value/convert/convert.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+import { FromType } from './from-type.mjs';
+/**
+ * Converts a value to the given type, coercing interior values if a reasonable conversion is possible. This
+ * function returns unknown so callers should Check the return value before use. This function mutates the
+ * provided value. If mutation is not wanted, you should Clone the value before passing to this function.
+ */
+export function Convert(...args) {
+    const [context, type, value] = Arguments.Match(args, {
+        3: (context, type, value) => [context, type, value],
+        2: (type, value) => [{}, type, value],
+    });
+    return FromType(context, type, value);
+}

package/build/value/convert/from-additional.d.mts

@@ -0,0 +1,6 @@
+import type { TSchema, TProperties } from '../../type/index.mjs';
+/**
+ * Used by Object and Record Types. The entries are derived from the known
+ * properties obtained from 'properties' and 'patternProperties' respectively.
+ */
+export declare function FromAdditionalProperties(context: TProperties, entries: [RegExp, TSchema][], additionalProperties: TSchema, value: Record<PropertyKey, unknown>): unknown;

package/build/value/convert/from-additional.mjs

@@ -0,0 +1,18 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+/**
+ * Used by Object and Record Types. The entries are derived from the known
+ * properties obtained from 'properties' and 'patternProperties' respectively.
+ */
+export function FromAdditionalProperties(context, entries, additionalProperties, value) {
+    const keys = Guard.Keys(value);
+    for (const [regexp, _] of entries) {
+        for (const key of keys) {
+            if (!regexp.test(key)) {
+                value[key] = FromType(context, additionalProperties, value[key]);
+            }
+        }
+    }
+    return value;
+}

package/build/value/convert/from-array.d.mts

@@ -0,0 +1,2 @@
+import type { TArray, TProperties } from '../../type/index.mjs';
+export declare function FromArray(context: TProperties, type: TArray, value: unknown): unknown;

package/build/value/convert/from-array.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromType } from './from-type.mjs';
+import { Guard } from '../../guard/index.mjs';
+export function FromArray(context, type, value) {
+    return Guard.IsArray(value)
+        ? value.map(value => FromType(context, type.items, value))
+        : value;
+}