typebox 1.2.19 → 1.3.1

package/build/type/engine/awaited/instantiate.d.mts

@@ -1,11 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
-import { type TProperties } from '../../types/properties.mjs';
-import { type TPromise } from '../../types/promise.mjs';
-import { type TAwaitedDeferred } from '../../action/awaited.mjs';
-import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TAwaitedOperation<Type extends TSchema> = (Type extends TPromise<infer Type extends TSchema> ? TAwaitedOperation<Type> : Type);
-export type TAwaitedAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TAwaitedOperation<Type> : TAwaitedDeferred<Type>> = Result;
-export declare function AwaitedAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TAwaitedAction<Type>;
-export type TAwaitedInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAwaitedAction<InstantiateType>;
-export declare function AwaitedInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAwaitedInstantiate<Context, State, Type>;
-export {};

package/build/type/engine/awaited/instantiate.mjs

@@ -1,20 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../../system/memory/index.mjs';
-import { IsPromise } from '../../types/promise.mjs';
-import { AwaitedDeferred } from '../../action/awaited.mjs';
-import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function AwaitedOperation(type) {
-    return (IsPromise(type)
-        ? AwaitedOperation(type.item)
-        : type);
-}
-export function AwaitedAction(type, options) {
-    const result = CanInstantiate([type])
-        ? Memory.Update(AwaitedOperation(type), {}, options)
-        : AwaitedDeferred(type, options);
-    return result;
-}
-export function AwaitedInstantiate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return AwaitedAction(instantiatedType, options);
-}

package/build/type/extends/async_iterator.d.mts

@@ -1,7 +0,0 @@
-import { type TSchema } from '../types/schema.mjs';
-import { type TProperties } from '../types/properties.mjs';
-import { type TAsyncIterator } from '../types/async_iterator.mjs';
-import { type TExtendsRight } from './extends_right.mjs';
-import { type TExtendsLeft } from './extends_left.mjs';
-export type TExtendsAsyncIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TAsyncIterator<infer Type extends TSchema> ? TExtendsLeft<Inferred, Left, Type> : TExtendsRight<Inferred, TAsyncIterator<Left>, Right>);
-export declare function ExtendsAsyncIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsAsyncIterator<Inferred, Left, Right>;

package/build/type/extends/async_iterator.mjs

@@ -1,9 +0,0 @@
-// deno-fmt-ignore-file
-import { AsyncIterator, IsAsyncIterator } from '../types/async_iterator.mjs';
-import { ExtendsRight } from './extends_right.mjs';
-import { ExtendsLeft } from './extends_left.mjs';
-export function ExtendsAsyncIterator(inferred, left, right) {
-    return (IsAsyncIterator(right)
-        ? ExtendsLeft(inferred, left, right.iteratorItems)
-        : ExtendsRight(inferred, AsyncIterator(left), right));
-}

package/build/type/extends/iterator.d.mts

@@ -1,7 +0,0 @@
-import { type TSchema } from '../types/schema.mjs';
-import { type TProperties } from '../types/properties.mjs';
-import { type TIterator } from '../types/iterator.mjs';
-import { type TExtendsRight } from './extends_right.mjs';
-import { type TExtendsLeft } from './extends_left.mjs';
-export type TExtendsIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TIterator<infer Type extends TSchema> ? TExtendsLeft<Inferred, Left, Type> : TExtendsRight<Inferred, TIterator<Left>, Right>);
-export declare function ExtendsIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsIterator<Inferred, Left, Right>;

package/build/type/extends/iterator.mjs

@@ -1,9 +0,0 @@
-// deno-fmt-ignore-file
-import { Iterator, IsIterator } from '../types/iterator.mjs';
-import { ExtendsRight } from './extends_right.mjs';
-import { ExtendsLeft } from './extends_left.mjs';
-export function ExtendsIterator(inferred, left, right) {
-    return (IsIterator(right)
-        ? ExtendsLeft(inferred, left, right.iteratorItems)
-        : ExtendsRight(inferred, Iterator(left), right));
-}

package/build/type/extends/promise.d.mts

@@ -1,7 +0,0 @@
-import { type TSchema } from '../types/schema.mjs';
-import { type TProperties } from '../types/properties.mjs';
-import { type TPromise } from '../types/promise.mjs';
-import { type TExtendsRight } from './extends_right.mjs';
-import { type TExtendsLeft } from './extends_left.mjs';
-export type TExtendsPromise<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TPromise<infer Type extends TSchema> ? TExtendsLeft<Inferred, Left, Type> : TExtendsRight<Inferred, TPromise<Left>, Right>);
-export declare function ExtendsPromise<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsPromise<Inferred, Left, Right>;

package/build/type/extends/promise.mjs

@@ -1,9 +0,0 @@
-// deno-fmt-ignore-file
-import { Promise, IsPromise } from '../types/promise.mjs';
-import { ExtendsRight } from './extends_right.mjs';
-import { ExtendsLeft } from './extends_left.mjs';
-export function ExtendsPromise(inferred, left, right) {
-    return (IsPromise(right)
-        ? ExtendsLeft(inferred, left, right.item)
-        : ExtendsRight(inferred, Promise(left), right));
-}

package/build/type/types/async_iterator.d.mts

@@ -1,20 +0,0 @@
-import { type StaticType, type StaticDirection } from './static.mjs';
-import { type TSchema, type TSchemaOptions } from './schema.mjs';
-import { type TProperties } from './properties.mjs';
-export type StaticAsyncIterator<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result = AsyncIterableIterator<StaticType<Stack, Direction, Context, This, Type>>> = Result;
-/** Represents a AsyncIterator. */
-export interface TAsyncIterator<Type extends TSchema = TSchema> extends TSchema {
-    '~kind': 'AsyncIterator';
-    type: 'asyncIterator';
-    iteratorItems: Type;
-}
-/**
- * Creates a AsyncIterator type.
- *
- * @deprecated This type is being removed in the next version of TypeBox. A fallback will be provided under examples.
- */
-export declare function AsyncIterator<Type extends TSchema>(iteratorItems: Type, options?: TSchemaOptions): TAsyncIterator<Type>;
-/** Returns true if the given value is a TAsyncIterator */
-export declare function IsAsyncIterator(value: unknown): value is TAsyncIterator;
-/** Extracts options from a TAsyncIterator. */
-export declare function AsyncIteratorOptions(type: TAsyncIterator): TSchemaOptions;

package/build/type/types/async_iterator.mjs

@@ -1,28 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/**
- * Creates a AsyncIterator type.
- *
- * @deprecated This type is being removed in the next version of TypeBox. A fallback will be provided under examples.
- */
-export function AsyncIterator(iteratorItems, options) {
-    return Memory.Create({ '~kind': 'AsyncIterator' }, { type: 'asyncIterator', iteratorItems }, options);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is a TAsyncIterator */
-export function IsAsyncIterator(value) {
-    return IsKind(value, 'AsyncIterator');
-}
-// ------------------------------------------------------------------
-// Options
-// ------------------------------------------------------------------
-/** Extracts options from a TAsyncIterator. */
-export function AsyncIteratorOptions(type) {
-    return Memory.Discard(type, ['~kind', 'type', 'iteratorItems']);
-}

package/build/type/types/base.d.mts

@@ -1,50 +0,0 @@
-import { type TSchema } from './schema.mjs';
-import { type XGuard, type XGuardInterface } from '../../schema/types/index.mjs';
-export type StaticBase<Value extends unknown> = Value;
-/**
- * @deprecated Use Type.Refine() + Type.Unsafe() instead.
- *
- *
- * **Reason:** It is noted that JavaScript class instances do not behave like
- * plain objects during structural clone or when the TB compositor needs to
- * assign dynamic modifier properties (such as '~optional').
- *
- * Because the TypeBox compositor needs to transform schematics via object clone /
- * property spread, these operations can result in class instance types losing
- * methods on the prototype (via clone), which can lead to unexpected structures being
- * returned. This has led to special-case (non-clone) handling for Base which needs
- * to be removed as it has proven orthogonal to the TypeBox 1.x design.
- *
- * The Base type was introduced in 1.x to try integrate / embed Standard Schema into JSON
- * Schema; however, support for integrated Standard Schema embedding will not be continued
- * in TypeBox. This type will be removed in the next minor revision of TypeBox.
- *
- * ```typescript
- * // (Deprecated)
- * class DateType extends Type.Base<Date> { Check(value) { return value instanceof Date } }
- *
- * // (Future)
- * const DateType = Type.Refine(Type.Unsafe<Date>({}), value => value instanceof Date)
- * ```
- */
-export declare class Base<Value extends unknown = unknown> implements TSchema, XGuard<Value> {
-    readonly '~kind': 'Base';
-    readonly '~guard': XGuardInterface<Value>;
-    constructor();
-    /** Checks a value or returns false if invalid */
-    Check(_value: unknown): _value is Value;
-    /** Returns errors for a value. Return an empty array if valid.  */
-    Errors(_value: unknown): object[];
-    /** Converts a value into this type */
-    Convert(value: unknown): unknown;
-    /** Cleans a value according to this type */
-    Clean(value: unknown): unknown;
-    /** Returns a default value for this type */
-    Default(value: unknown): unknown;
-    /** Creates a new instance of this type */
-    Create(): Value;
-    /** Clones this type  */
-    Clone(): Base;
-}
-/** Returns true if the given value is a Base type. */
-export declare function IsBase(value: unknown): value is Base;

package/build/type/types/base.mjs

@@ -1,84 +0,0 @@
-// deno-fmt-ignore-file
-import { Settings } from '../../system/settings/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// Type.Base<...>
-// ------------------------------------------------------------------
-function BaseProperty(value) {
-    return {
-        enumerable: Settings.Get().enumerableKind,
-        writable: false,
-        configurable: false,
-        value
-    };
-}
-/**
- * @deprecated Use Type.Refine() + Type.Unsafe() instead.
- *
- *
- * **Reason:** It is noted that JavaScript class instances do not behave like
- * plain objects during structural clone or when the TB compositor needs to
- * assign dynamic modifier properties (such as '~optional').
- *
- * Because the TypeBox compositor needs to transform schematics via object clone /
- * property spread, these operations can result in class instance types losing
- * methods on the prototype (via clone), which can lead to unexpected structures being
- * returned. This has led to special-case (non-clone) handling for Base which needs
- * to be removed as it has proven orthogonal to the TypeBox 1.x design.
- *
- * The Base type was introduced in 1.x to try integrate / embed Standard Schema into JSON
- * Schema; however, support for integrated Standard Schema embedding will not be continued
- * in TypeBox. This type will be removed in the next minor revision of TypeBox.
- *
- * ```typescript
- * // (Deprecated)
- * class DateType extends Type.Base<Date> { Check(value) { return value instanceof Date } }
- *
- * // (Future)
- * const DateType = Type.Refine(Type.Unsafe<Date>({}), value => value instanceof Date)
- * ```
- */
-export class Base {
-    constructor() {
-        globalThis.Object.defineProperty(this, '~kind', BaseProperty('Base'));
-        globalThis.Object.defineProperty(this, '~guard', BaseProperty({
-            check: (value) => this.Check(value),
-            errors: (value) => this.Errors(value)
-        }));
-    }
-    /** Checks a value or returns false if invalid */
-    Check(_value) {
-        return true;
-    }
-    /** Returns errors for a value. Return an empty array if valid.  */
-    Errors(_value) {
-        return [];
-    }
-    /** Converts a value into this type */
-    Convert(value) {
-        return value;
-    }
-    /** Cleans a value according to this type */
-    Clean(value) {
-        return value;
-    }
-    /** Returns a default value for this type */
-    Default(value) {
-        return value;
-    }
-    /** Creates a new instance of this type */
-    Create() {
-        throw new Error('Create not implemented');
-    }
-    /** Clones this type  */
-    Clone() {
-        throw Error('Clone not implemented');
-    }
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is a Base type. */
-export function IsBase(value) {
-    return IsKind(value, 'Base');
-}

package/build/type/types/iterator.d.mts

@@ -1,20 +0,0 @@
-import { type StaticType, type StaticDirection } from './static.mjs';
-import { type TSchema, type TSchemaOptions } from './schema.mjs';
-import { type TProperties } from './properties.mjs';
-export type StaticIterator<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result = IterableIterator<StaticType<Stack, Direction, Context, This, Type>>> = Result;
-/** Represents an Iterator. */
-export interface TIterator<Type extends TSchema = TSchema> extends TSchema {
-    '~kind': 'Iterator';
-    type: 'iterator';
-    iteratorItems: Type;
-}
-/**
- * Creates a Iterator type.
- *
- * @deprecated This type is being removed in the next version of TypeBox. A fallback will be provided under examples.
- */
-export declare function Iterator<Type extends TSchema>(iteratorItems: Type, options?: TSchemaOptions): TIterator<Type>;
-/** Returns true if the given value is TIterator. */
-export declare function IsIterator(value: unknown): value is TIterator;
-/** Extracts options from a TIterator. */
-export declare function IteratorOptions(type: TIterator): TSchemaOptions;

package/build/type/types/iterator.mjs

@@ -1,28 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/**
- * Creates a Iterator type.
- *
- * @deprecated This type is being removed in the next version of TypeBox. A fallback will be provided under examples.
- */
-export function Iterator(iteratorItems, options) {
-    return Memory.Create({ '~kind': 'Iterator' }, { type: 'iterator', iteratorItems }, options);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is TIterator. */
-export function IsIterator(value) {
-    return IsKind(value, 'Iterator');
-}
-// ------------------------------------------------------------------
-// Options
-// ------------------------------------------------------------------
-/** Extracts options from a TIterator. */
-export function IteratorOptions(type) {
-    return Memory.Discard(type, ['~kind', 'type', 'iteratorItems']);
-}

package/build/type/types/promise.d.mts

@@ -1,21 +0,0 @@
-import { type StaticType, type StaticDirection } from './static.mjs';
-import { type TSchema, type TSchemaOptions } from './schema.mjs';
-import { type TProperties } from './properties.mjs';
-export type StaticPromise<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result = Promise<StaticType<Stack, Direction, Context, This, Type>>> = Result;
-/** Represents a Promise type. */
-export interface TPromise<Type extends TSchema = TSchema> extends TSchema {
-    '~kind': 'Promise';
-    type: 'promise';
-    item: Type;
-}
-/**
- * Creates a Promise type.
- *
- * @deprecated This type is being removed in the next version of TypeBox. A fallback will be provided under examples.
- */
-export declare function _Promise_<Type extends TSchema>(item: Type, options?: TSchemaOptions): TPromise<Type>;
-export { _Promise_ as Promise };
-/** Returns true if the given type is TPromise. */
-export declare function IsPromise(value: unknown): value is TPromise;
-/** Extracts options from a TPromise. */
-export declare function PromiseOptions(type: TPromise): TSchemaOptions;

package/build/type/types/promise.mjs

@@ -1,29 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/**
- * Creates a Promise type.
- *
- * @deprecated This type is being removed in the next version of TypeBox. A fallback will be provided under examples.
- */
-export function _Promise_(item, options) {
-    return Memory.Create({ ['~kind']: 'Promise' }, { type: 'promise', item }, options);
-}
-export { _Promise_ as Promise };
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given type is TPromise. */
-export function IsPromise(value) {
-    return IsKind(value, 'Promise');
-}
-// ------------------------------------------------------------------
-// Options
-// ------------------------------------------------------------------
-/** Extracts options from a TPromise. */
-export function PromiseOptions(type) {
-    return Memory.Discard(type, ['~kind', 'type', 'item']);
-}

package/build/value/clean/from_base.d.mts

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

package/build/value/clean/from_base.mjs

@@ -1,4 +0,0 @@
-// deno-fmt-ignore-file
-export function FromBase(_context, type, value) {
-    return type.Clean(value);
-}

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

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

package/build/value/convert/from_base.mjs

@@ -1,4 +0,0 @@
-// deno-fmt-ignore-file
-export function FromBase(_context, type, value) {
-    return type.Convert(value);
-}

package/build/value/create/from_async_iterator.d.mts

@@ -1,2 +0,0 @@
-import type { TProperties, TAsyncIterator } from '../../type/index.mjs';
-export declare function FromAsyncIterator(_context: TProperties, _type: TAsyncIterator): unknown;

package/build/value/create/from_async_iterator.mjs

@@ -1,5 +0,0 @@
-// deno-fmt-ignore-file
-async function* CreateAsyncIterator() { }
-export function FromAsyncIterator(_context, _type) {
-    return CreateAsyncIterator();
-}

package/build/value/create/from_base.d.mts

@@ -1,2 +0,0 @@
-import type { TProperties, Base } from '../../type/index.mjs';
-export declare function FromBase(_context: TProperties, type: Base): unknown;

package/build/value/create/from_base.mjs

@@ -1,4 +0,0 @@
-// deno-fmt-ignore-file
-export function FromBase(_context, type) {
-    return type.Create();
-}

package/build/value/create/from_iterator.d.mts

@@ -1,2 +0,0 @@
-import type { TProperties, TIterator } from '../../type/index.mjs';
-export declare function FromIterator(_context: TProperties, _type: TIterator): unknown;

package/build/value/create/from_iterator.mjs

@@ -1,5 +0,0 @@
-// deno-fmt-ignore-file
-function* CreateIterator() { }
-export function FromIterator(_context, _type) {
-    return CreateIterator();
-}

package/build/value/create/from_promise.d.mts

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

package/build/value/create/from_promise.mjs

@@ -1,5 +0,0 @@
-// deno-fmt-ignore-file
-import { FromType } from './from_type.mjs';
-export function FromPromise(context, type) {
-    return Promise.resolve(FromType(context, type.item));
-}

package/build/value/default/from_base.d.mts

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

package/build/value/default/from_base.mjs

@@ -1,5 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file 
-export function FromBase(context, type, value) {
-    return type.Default(value);
-}

package/build/value/mutate/error.d.mts

@@ -1,3 +0,0 @@
-export declare class MutateError extends Error {
-    constructor(message: string);
-}

package/build/value/mutate/error.mjs

@@ -1,6 +0,0 @@
-// deno-fmt-ignore-file
-export class MutateError extends Error {
-    constructor(message) {
-        super(message);
-    }
-}

package/build/value/mutate/from_array.d.mts

@@ -1,2 +0,0 @@
-import { type TMutable } from './mutate.mjs';
-export declare function FromArray(root: TMutable, path: string, current: unknown, next: unknown[]): void;

package/build/value/mutate/from_array.mjs

@@ -1,16 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { Clone } from '../clone/index.mjs';
-import { Pointer } from '../pointer/index.mjs';
-import { FromValue } from './from_value.mjs';
-export function FromArray(root, path, current, next) {
-    if (!Guard.IsArray(current)) {
-        Pointer.Set(root, path, Clone(next));
-    }
-    else {
-        for (let index = 0; index < next.length; index++) {
-            FromValue(root, `${path}/${index}`, current[index], next[index]);
-        }
-        current.splice(next.length);
-    }
-}

package/build/value/mutate/from_object.d.mts

@@ -1,2 +0,0 @@
-import { type TMutable } from './mutate.mjs';
-export declare function FromObject(root: TMutable, path: string, current: unknown, next: Record<string, unknown>): void;

package/build/value/mutate/from_object.mjs

@@ -1,40 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { Pointer } from '../pointer/index.mjs';
-import { Clone } from '../clone/index.mjs';
-import { FromValue } from './from_value.mjs';
-// ------------------------------------------------------------------
-// AssertKey
-// ------------------------------------------------------------------
-function AssertKey(key) {
-    if (Guard.IsUnsafePropertyKey(key))
-        throw Error('Attempted to Mutate with unsafe property key');
-}
-// ------------------------------------------------------------------
-// AssertKey
-// ------------------------------------------------------------------
-export function FromObject(root, path, current, next) {
-    if (!Guard.IsObjectNotArray(current)) {
-        Pointer.Set(root, path, Clone(next));
-    }
-    else {
-        const currentKeys = Guard.Keys(current);
-        const nextKeys = Guard.Keys(next);
-        for (const currentKey of currentKeys) {
-            AssertKey(currentKey);
-            if (!nextKeys.includes(currentKey)) {
-                delete current[currentKey];
-            }
-        }
-        for (const nextKey of nextKeys) {
-            AssertKey(nextKey);
-            if (!currentKeys.includes(nextKey)) {
-                current[nextKey] = next[nextKey];
-            }
-        }
-        for (const nextKey of nextKeys) {
-            AssertKey(nextKey);
-            FromValue(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
-        }
-    }
-}

package/build/value/mutate/from_unknown.d.mts

@@ -1,2 +0,0 @@
-import { type TMutable } from './mutate.mjs';
-export declare function FromUnknown(root: TMutable, path: string, current: unknown, next: unknown): void;

package/build/value/mutate/from_unknown.mjs

@@ -1,7 +0,0 @@
-// deno-fmt-ignore-file
-import { Pointer } from '../pointer/index.mjs';
-export function FromUnknown(root, path, current, next) {
-    if (current === next)
-        return;
-    Pointer.Set(root, path, next);
-}

package/build/value/mutate/from_value.d.mts

@@ -1,2 +0,0 @@
-import { type TMutable } from './mutate.mjs';
-export declare function FromValue(root: TMutable, path: string, current: unknown, next: unknown): void;

package/build/value/mutate/from_value.mjs

@@ -1,12 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { FromArray } from './from_array.mjs';
-import { FromObject } from './from_object.mjs';
-import { FromUnknown } from './from_unknown.mjs';
-export function FromValue(root, path, current, next) {
-    if (Guard.IsArray(next))
-        return FromArray(root, path, current, next);
-    if (Guard.IsObject(next))
-        return FromObject(root, path, current, next);
-    return FromUnknown(root, path, current, next);
-}

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

@@ -1 +0,0 @@
-export * from './mutate.mjs';

package/build/value/mutate/index.mjs

@@ -1 +0,0 @@
-export * from './mutate.mjs';

package/build/value/mutate/mutate.d.mts

@@ -1,11 +0,0 @@
-export type TMutable = {
-    [key: string]: unknown;
-} | unknown[];
-/**
- * Performs a deep structural assignment, applying values from next to current while retaining internal references. This function
- * is written for use in infrastructure that interprets reference changes as a signal to perform some action (i.e. React redraw), this
- * function can mitigate this by applying mutable updates deep within a value, ensuring parent references are retained.
- *
- * @deprecated This function is being removed in the next version but will be retained as a reference under examples.
- */
-export declare function Mutate(current: TMutable, next: TMutable): void;

package/build/value/mutate/mutate.mjs

@@ -1,41 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard, GlobalsGuard } from '../../guard/index.mjs';
-import { MutateError } from './error.mjs';
-import { FromValue } from './from_value.mjs';
-// ------------------------------------------------------------------
-// IsNonMutableValue
-// ------------------------------------------------------------------
-function IsNonMutableValue(value) {
-    return GlobalsGuard.IsTypeArray(value)
-        || GlobalsGuard.IsDate(value)
-        || GlobalsGuard.IsMap(value)
-        || GlobalsGuard.IsSet(value)
-        || Guard.IsNumber(value)
-        || Guard.IsString(value)
-        || Guard.IsBoolean(value)
-        || Guard.IsSymbol(value);
-}
-// ------------------------------------------------------------------
-// IsTrueObject
-// ------------------------------------------------------------------
-function IsMismatchedValue(left, right) {
-    return ((Guard.IsObjectNotArray(left) && Guard.IsArray(right)) ||
-        (Guard.IsArray(left) && Guard.IsObjectNotArray(right)));
-}
-// ------------------------------------------------------------------
-// Mutate
-// ------------------------------------------------------------------
-/**
- * Performs a deep structural assignment, applying values from next to current while retaining internal references. This function
- * is written for use in infrastructure that interprets reference changes as a signal to perform some action (i.e. React redraw), this
- * function can mitigate this by applying mutable updates deep within a value, ensuring parent references are retained.
- *
- * @deprecated This function is being removed in the next version but will be retained as a reference under examples.
- */
-export function Mutate(current, next) {
-    if (IsNonMutableValue(current) || IsNonMutableValue(next))
-        throw new MutateError('Only object and array types can be mutated at the root level');
-    if (IsMismatchedValue(current, next))
-        throw new MutateError('Cannot assign due type mismatch of assignable values');
-    FromValue(current, '', current, next);
-}