typebox 1.1.27 → 1.1.29

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

@@ -9,7 +9,8 @@ export interface TPromise<Type extends TSchema = TSchema> extends TSchema {
     item: Type;
 }
 /** Creates a Promise type. */
-export declare function Promise<Type extends TSchema>(item: Type, options?: TSchemaOptions): TPromise<Type>;
+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. */

package/build/type/types/promise.mjs

@@ -5,9 +5,10 @@ import { IsKind } from './schema.mjs';
 // Factory
 // ------------------------------------------------------------------
 /** Creates a Promise type. */
-export function Promise(item, options) {
+export function _Promise_(item, options) {
     return Memory.Create({ ['~kind']: 'Promise' }, { type: 'promise', item }, options);
 }
+export { _Promise_ as Promise };
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------

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

@@ -30,8 +30,9 @@ export type TRequiredArray<Properties extends TProperties, RequiredProperties ex
 }, RequiredKeys extends string[] = TUnionToTuple<Extract<keyof RequiredProperties, string>>, Result extends string[] | undefined = RequiredKeys extends [] ? undefined : RequiredKeys> = Result;
 /** Creates a RequiredArray derived from the given TProperties value. */
 export declare function RequiredArray<Properties extends TProperties>(properties: Properties): TRequiredArray<Properties>;
+type TKeyToString<Key extends number | string> = `${Key}`;
 /** Extracts a tuple of keys from a TProperties value. */
-export type TPropertyKeys<Properties extends TProperties, Result extends string[] = TUnionToTuple<Extract<keyof Properties, string>>> = Result;
+export type TPropertyKeys<Properties extends TProperties, ExtractKey extends number | string = Extract<keyof Properties, number | string>, StringKey extends string = TKeyToString<ExtractKey>, Result extends string[] = TUnionToTuple<StringKey>> = Result;
 /** Extracts a tuple of keys from a TProperties value. */
 export declare function PropertyKeys<Properties extends TProperties>(properties: Properties): TPropertyKeys<Properties>;
 type TPropertyValuesReduce<Properties extends TProperties, Keys extends string[], Result extends TSchema[] = []> = Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends keyof Properties ? TPropertyValuesReduce<Properties, Right, [...Result, Properties[Left]]> : TPropertyValuesReduce<Properties, Right, Result> : Result;

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

@@ -5,9 +5,9 @@ import { type TInteger } from './integer.mjs';
 import { type TNumber } from './number.mjs';
 import { type TString } from './string.mjs';
 import { type TDeferred } from './deferred.mjs';
-import { type TInstantiate } from '../engine/instantiate.mjs';
 import { type TTemplateLiteralStatic } from '../engine/template-literal/index.mjs';
 import { type TTemplateLiteralDecodeUnsafe } from '../engine/template-literal/decode.mjs';
+import { type TRecordAction } from '../engine/record/instantiate.mjs';
 type StaticPropertyKey<Key extends string, Result extends PropertyKey = (Key extends TStringKey ? string : Key extends TIntegerKey ? number : Key extends TNumberKey ? number : Key extends `^${string}$` ? TTemplateLiteralStatic<Key> : string)> = Result;
 export type StaticRecord<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Key extends string, Value extends TSchema, StaticKey extends PropertyKey = StaticPropertyKey<Key>, StaticValue extends unknown = StaticType<Stack, Direction, Context, This, Value>, Result extends Record<PropertyKey, unknown> = Record<StaticKey, StaticValue>> = Result;
 export type TStringKey = typeof StringKey;
@@ -24,13 +24,11 @@ export interface TRecord<Key extends string = string, Value extends TSchema = TS
     };
 }
 /** Represents a deferred Record action. */
-export type TRecordDeferred<Key extends TSchema, Value extends TSchema> = (TDeferred<'Record', [Key, Value]>);
+export type TRecordDeferred<Key extends TSchema = TSchema, Value extends TSchema = TSchema> = (TDeferred<'Record', [Key, Value]>);
 /** Represents a deferred Record action. */
 export declare function RecordDeferred<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordDeferred<Key, Value>;
-export type TRecordConstruct<Key extends TSchema, Value extends TSchema> = (TInstantiate<{}, TRecordDeferred<Key, Value>>);
-export declare function RecordConstruct<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordConstruct<Key, Value>;
 /** Creates a Record type. */
-export declare function Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordConstruct<Key, Value>;
+export declare function Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordAction<Key, Value>;
 /** Creates a Record type from regular expression pattern. */
 export declare function RecordFromPattern<Pattern extends string, Value extends TSchema>(key: Pattern, value: Value): TRecord<Pattern, Value>;
 /** Returns the raw string pattern used for the Record key  */

package/build/type/types/record.mjs

@@ -1,4 +1,3 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';
@@ -7,9 +6,9 @@ import { Integer, IntegerPattern } from './integer.mjs';
 import { Number, NumberPattern } from './number.mjs';
 import { String, StringPattern } from './string.mjs';
 import { Deferred } from './deferred.mjs';
-import { Instantiate } from '../engine/instantiate.mjs';
 import { TemplateLiteralDecodeUnsafe } from '../engine/template-literal/decode.mjs';
 import { CreateRecord } from '../engine/record/record-create.mjs';
+import { RecordAction } from '../engine/record/instantiate.mjs';
 export const IntegerKey = `^${IntegerPattern}$`;
 export const NumberKey = `^${NumberPattern}$`;
 export const StringKey = `^${StringPattern}$`;
@@ -17,15 +16,12 @@ export const StringKey = `^${StringPattern}$`;
 export function RecordDeferred(key, value, options = {}) {
     return Deferred('Record', [key, value], options);
 }
-export function RecordConstruct(key, value, options = {}) {
-    return Instantiate({}, RecordDeferred(key, value, options));
-}
 // -------------------------------------------------------------------
 // Factory
 // -------------------------------------------------------------------
 /** Creates a Record type. */
 export function Record(key, value, options = {}) {
-    return RecordConstruct(key, value, options);
+    return RecordAction(key, value, options);
 }
 // -------------------------------------------------------------------
 // FromPattern

package/build/type/types/template-literal.d.mts

@@ -1,8 +1,8 @@
 import { type TSchema, type TSchemaOptions } from './schema.mjs';
 import { type TDeferred } from './deferred.mjs';
 import { type TParseTemplateIntoTypes } from '../engine/patterns/template.mjs';
-import { type TInstantiate } from '../engine/instantiate.mjs';
 import { type TTemplateLiteralStatic } from '../engine/template-literal/static.mjs';
+import { type TTemplateLiteralAction } from '../engine/template-literal/instantiate.mjs';
 export type StaticTemplateLiteral<Pattern extends string> = (TTemplateLiteralStatic<Pattern>);
 /** Represents a TemplateLiteral type. */
 export interface TTemplateLiteral<Pattern extends string = string> extends TSchema {
@@ -11,10 +11,12 @@ export interface TTemplateLiteral<Pattern extends string = string> extends TSche
     pattern: Pattern;
 }
 /** Creates a deferred TemplateLiteral action. */
-export type TTemplateLiteralDeferred<Types extends TSchema[]> = (TDeferred<'TemplateLiteral', [Types]>);
+export type TTemplateLiteralDeferred<Types extends TSchema[] = TSchema[]> = (TDeferred<'TemplateLiteral', [Types]>);
 /** Creates a deferred TemplateLiteral action. */
 export declare function TemplateLiteralDeferred<Types extends TSchema[]>(types: [...Types], options?: TSchemaOptions): TTemplateLiteralDeferred<Types>;
-export type TTemplateLiteralFromTypes<Types extends TSchema[], Result extends TSchema = TInstantiate<{}, TTemplateLiteralDeferred<Types>>> = Result;
+/** Returns true if this value is a deferred Interface action. */
+export declare function IsTemplateLiteralDeferred(value: unknown): value is TTemplateLiteralDeferred;
+export type TTemplateLiteralFromTypes<Types extends TSchema[], Result extends TSchema = TTemplateLiteralAction<Types>> = Result;
 export declare function TemplateLiteralFromTypes<Types extends TSchema[]>(types: [...Types]): TTemplateLiteralFromTypes<Types>;
 export type TTemplateLiteralFromString<Template extends string, Types extends TSchema[] = TParseTemplateIntoTypes<Template>, Result extends TSchema = TTemplateLiteralFromTypes<Types>> = Result;
 export declare function TemplateLiteralFromString<Template extends string>(template: Template): TTemplateLiteralFromString<Template>;

package/build/type/types/template-literal.mjs

@@ -1,17 +1,23 @@
 // deno-fmt-ignore-file
 // deno-lint-ignore-file
+import { Memory } from '../../system/system.mjs';
 import { Guard } from '../../guard/index.mjs';
-import { IsKind } from './schema.mjs';
+import { IsSchema, IsKind } from './schema.mjs';
 import { Deferred } from './deferred.mjs';
 import { ParseTemplateIntoTypes } from '../engine/patterns/template.mjs';
-import { Instantiate } from '../engine/instantiate.mjs';
-import { Memory } from '../../system/system.mjs';
+import { TemplateLiteralAction } from '../engine/template-literal/instantiate.mjs';
 /** Creates a deferred TemplateLiteral action. */
 export function TemplateLiteralDeferred(types, options = {}) {
     return Deferred('TemplateLiteral', [types], options);
 }
+/** Returns true if this value is a deferred Interface action. */
+export function IsTemplateLiteralDeferred(value) {
+    return IsSchema(value)
+        && Guard.HasPropertyKey(value, 'action')
+        && Guard.IsEqual(value.action, 'TemplateLiteral');
+}
 export function TemplateLiteralFromTypes(types) {
-    return Instantiate({}, TemplateLiteralDeferred(types, {}));
+    return TemplateLiteralAction(types, {});
 }
 export function TemplateLiteralFromString(template) {
     const types = ParseTemplateIntoTypes(template);

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

@@ -2,8 +2,7 @@ import { type TSchema } from './schema.mjs';
 export type StaticUnsafe<Type extends unknown> = Type;
 /** Represents an Unsafe type. */
 export interface TUnsafe<Type extends unknown = unknown> extends TSchema {
-    '~kind': 'Unsafe';
-    '~hint': Type;
+    '~unsafe': Type;
 }
 /** Creates a Unsafe type. */
 export declare function Unsafe<Type extends unknown>(schema: TSchema): TUnsafe<Type>;

package/build/type/types/unsafe.mjs

@@ -1,18 +1,20 @@
 // deno-fmt-ignore-file
 // deno-lint-ignore-file 
+import { Guard } from '../../guard/index.mjs';
 import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
 // ------------------------------------------------------------------
 // Factory
 // ------------------------------------------------------------------
 /** Creates a Unsafe type. */
 export function Unsafe(schema) {
-    return Memory.Create({ ['~kind']: 'Unsafe' }, {}, schema);
+    return Memory.Update(schema, { ['~unsafe']: null }, {});
 }
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------
 /** Returns true if the given value is TUnsafe. */
 export function IsUnsafe(value) {
-    return IsKind(value, 'Unsafe');
+    return Guard.IsObjectNotArray(value)
+        && Guard.HasPropertyKey(value, '~unsafe')
+        && Guard.IsNull(value['~unsafe']);
 }

package/build/typebox.d.mts

@@ -1,7 +1,7 @@
 export { Instantiate, type TInstantiate } from './type/engine/instantiate.mjs';
 export { Extends, ExtendsResult, type TExtends } from './type/extends/index.mjs';
 export { Script, type TScript } from './type/script/index.mjs';
-export { Awaited, type AwaitedDeferred, type TAwaited } from './type/action/awaited.mjs';
+export { Awaited, type TAwaited, type TAwaitedDeferred } from './type/action/awaited.mjs';
 export { Capitalize, type TCapitalize, type TCapitalizeDeferred } from './type/action/capitalize.mjs';
 export { Conditional, type TConditional, type TConditionalDeferred } from './type/action/conditional.mjs';
 export { ConstructorParameters, type TConstructorParameters, type TConstructorParametersDeferred } from './type/action/constructor-parameters.mjs';
@@ -21,7 +21,7 @@ export { Options, type TOptions } from './type/action/options.mjs';
 export { Parameters, type TParameters, type TParametersDeferred } from './type/action/parameters.mjs';
 export { Partial, type TPartial, type TPartialDeferred } from './type/action/partial.mjs';
 export { Pick, type TPick, type TPickDeferred } from './type/action/pick.mjs';
-export { ReadonlyType, type TReadonlyType, type TReadonlyTypeDeferred } from './type/action/readonly-type.mjs';
+export { ReadonlyObject, ReadonlyType, type TReadonlyObject, type TReadonlyObjectDeferred } from './type/action/readonly-object.mjs';
 export { Required, type TRequired, type TRequiredDeferred } from './type/action/required.mjs';
 export { ReturnType, type TReturnType, type TReturnTypeDeferred } from './type/action/return-type.mjs';
 export { type TUncapitalize, type TUncapitalizeDeferred, Uncapitalize } from './type/action/uncapitalize.mjs';
@@ -30,7 +30,7 @@ export { Codec, Decode, DecodeBuilder, Encode, EncodeBuilder, IsCodec, type TCod
 export { Immutable, IsImmutable, type TImmutable } from './type/types/_immutable.mjs';
 export { IsOptional, Optional, type TOptional } from './type/types/_optional.mjs';
 export { IsReadonly, Readonly, type TReadonly } from './type/types/_readonly.mjs';
-export { IsRefine, Refine, type TRefine, type TRefineCallback, type TRefinement } from './type/types/_refine.mjs';
+export { IsRefine, Refine, type TRefine, type TRefineCheckCallback, type TRefineErrorCallback, type TRefinement } from './type/types/_refine.mjs';
 export { Any, IsAny, type TAny } from './type/types/any.mjs';
 export { Array, IsArray, type TArray } from './type/types/array.mjs';
 export { AsyncIterator, IsAsyncIterator, type TAsyncIterator } from './type/types/async-iterator.mjs';
@@ -56,7 +56,7 @@ export { IsObject, Object, type TObject } from './type/types/object.mjs';
 export { IsParameter, Parameter, type TParameter } from './type/types/parameter.mjs';
 export { IsPromise, Promise, type TPromise } from './type/types/promise.mjs';
 export { type TProperties, type TRequiredArray } from './type/types/properties.mjs';
-export { IsRecord, Record, RecordKey, RecordPattern as RecordKeyAsPattern, RecordValue, type TRecord, type TRecordKey as TRecordKey, type TRecordPattern as TRecordKeyAsPattern, type TRecordValue } from './type/types/record.mjs';
+export { IsRecord, Record, RecordKey, RecordPattern, RecordValue, type TRecord, type TRecordKey, type TRecordPattern, type TRecordValue } from './type/types/record.mjs';
 export { IsRef, Ref, type TRef } from './type/types/ref.mjs';
 export { IsRest, Rest, type TRest } from './type/types/rest.mjs';
 export { IsKind, IsSchema, type TArrayOptions, type TFormat, type TIntersectOptions, type TNumberOptions, type TObjectOptions, type TSchema, type TSchemaOptions, type TStringOptions, type TTupleOptions } from './type/types/schema.mjs';

package/build/typebox.mjs

@@ -33,7 +33,7 @@ export { Options } from './type/action/options.mjs';
 export { Parameters } from './type/action/parameters.mjs';
 export { Partial } from './type/action/partial.mjs';
 export { Pick } from './type/action/pick.mjs';
-export { ReadonlyType } from './type/action/readonly-type.mjs';
+export { ReadonlyObject, ReadonlyType } from './type/action/readonly-object.mjs';
 export { Required } from './type/action/required.mjs';
 export { ReturnType } from './type/action/return-type.mjs';
 export { Uncapitalize } from './type/action/uncapitalize.mjs';
@@ -73,7 +73,7 @@ export { IsNumber, Number } from './type/types/number.mjs';
 export { IsObject, Object } from './type/types/object.mjs';
 export { IsParameter, Parameter } from './type/types/parameter.mjs';
 export { IsPromise, Promise } from './type/types/promise.mjs';
-export { IsRecord, Record, RecordKey, RecordPattern as RecordKeyAsPattern, RecordValue } from './type/types/record.mjs';
+export { IsRecord, Record, RecordKey, RecordPattern, RecordValue } from './type/types/record.mjs';
 export { IsRef, Ref } from './type/types/ref.mjs';
 export { IsRest, Rest } from './type/types/rest.mjs';
 export { IsKind, IsSchema } from './type/types/schema.mjs';

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

@@ -5,5 +5,7 @@ export type TMutable = {
  * 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

@@ -29,6 +29,8 @@ function IsMismatchedValue(left, right) {
  * 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))

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.1.27",
+  "version": "1.1.29",
   "keywords": [
     "typescript",
     "jsonschema"

package/build/type/action/readonly-type.d.mts

@@ -1,11 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
-import { type TDeferred } from '../types/deferred.mjs';
-import { type TInstantiate } from '../engine/instantiate.mjs';
-/** Creates a deferred ReadonlyType action. */
-export type TReadonlyTypeDeferred<Type extends TSchema> = (TDeferred<'ReadonlyType', [Type]>);
-/** Creates a deferred ReadonlyType action. */
-export declare function ReadonlyTypeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TDeferred<"ReadonlyType", [Type]>;
-/** This type is an alias for the TypeScript `Readonly<T>` utility type. */
-export type TReadonlyType<Type extends TSchema> = (TInstantiate<{}, TReadonlyTypeDeferred<Type>>);
-/** This type is an alias for the TypeScript `Readonly<T>` utility type. */
-export declare function ReadonlyType<Type extends TSchema>(type: Type, options?: TSchemaOptions): TReadonlyType<Type>;

package/build/type/action/readonly-type.mjs

@@ -1,12 +0,0 @@
-// deno-lint-ignore-file ban-types
-// deno-fmt-ignore-file
-import { Deferred } from '../types/deferred.mjs';
-import { Instantiate } from '../engine/instantiate.mjs';
-/** Creates a deferred ReadonlyType action. */
-export function ReadonlyTypeDeferred(type, options = {}) {
-    return Deferred('ReadonlyType', [type], options);
-}
-/** This type is an alias for the TypeScript `Readonly<T>` utility type. */
-export function ReadonlyType(type, options = {}) {
-    return Instantiate({}, ReadonlyTypeDeferred(type, options));
-}

package/build/type/engine/readonly-type/instantiate.d.mts

@@ -1,9 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
-import { type TProperties } from '../../types/properties.mjs';
-import { type TReadonlyTypeDeferred } from '../../action/readonly-type.mjs';
-import { type TFromType } from './from-type.mjs';
-import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TReadonlyTypeImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<InstantiatedType>;
-export type TReadonlyTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TReadonlyTypeImmediate<Context, State, Type> : TReadonlyTypeDeferred<Type>;
-export declare function ReadonlyTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TReadonlyTypeInstantiate<Context, State, Type>;
-export {};

package/build/type/engine/readonly-type/instantiate.mjs

@@ -1,14 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../../system/memory/index.mjs';
-import { ReadonlyTypeDeferred } from '../../action/readonly-type.mjs';
-import { FromType } from './from-type.mjs';
-import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function ReadonlyTypeImmediate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(FromType(instantiatedType), {}, options);
-}
-export function ReadonlyTypeInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? ReadonlyTypeImmediate(context, state, type, options)
-        : ReadonlyTypeDeferred(type, options));
-}