typebox 1.1.28 → 1.1.29

package/build/schema/engine/_refine.mjs

@@ -6,24 +6,24 @@ import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 export function BuildRefine(_stack, _context, schema, value) {
     const refinements = V.CreateVariable(schema['~refine'].map((refinement) => refinement));
-    return E.Every(refinements, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'refine'), [value]));
+    return E.Every(refinements, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'check'), [value]));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckRefine(_stack, _context, schema, value) {
-    return G.Every(schema['~refine'], 0, (refinement, _) => refinement.refine(value));
+    return G.Every(schema['~refine'], 0, (refinement, _) => refinement.check(value));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
 export function ErrorRefine(_stack, context, schemaPath, instancePath, schema, value) {
     return G.EveryAll(schema['~refine'], 0, (refinement, index) => {
-        return refinement.refine(value) || context.AddError({
+        return refinement.check(value) || context.AddError({
             keyword: '~refine',
             schemaPath,
             instancePath,
-            params: { index, message: refinement.message },
+            params: { index, message: refinement.error(value) },
         });
     });
 }

package/build/schema/types/_refine.d.mts

@@ -1,7 +1,7 @@
 import type { XSchemaObject } from './schema.mjs';
 export interface XRefinement {
-    refine: (value: unknown) => boolean;
-    message: string;
+    check: (value: unknown) => boolean;
+    error: (value: unknown) => string;
 }
 export interface XRefine<Refinements extends XRefinement[] = XRefinement[]> {
     '~refine': Refinements;

package/build/schema/types/_refine.mjs

@@ -11,8 +11,8 @@ export function IsRefine(value) {
     return Guard.HasPropertyKey(value, '~refine')
         && Guard.IsArray(value["~refine"])
         && Guard.Every(value['~refine'], 0, value => Guard.IsObject(value)
-            && Guard.HasPropertyKey(value, 'refine')
-            && Guard.HasPropertyKey(value, 'message')
-            && Guard.IsFunction(value.refine)
-            && Guard.IsString(value.message));
+            && Guard.HasPropertyKey(value, 'check')
+            && Guard.HasPropertyKey(value, 'error')
+            && Guard.IsFunction(value.check)
+            && Guard.IsFunction(value.error));
 }

package/build/type/engine/indexed/from-object.d.mts

@@ -1,9 +1,14 @@
 import { type TProperties } from '../../types/properties.mjs';
 import { type TSchema } from '../../types/schema.mjs';
+import { type TNumber } from '../../types/number.mjs';
+import { type TPropertyKeys } from '../../types/properties.mjs';
 import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
 import { type TToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
-type TSelectProperty<Properties extends TProperties, Key extends string, PropertyKey extends string = keyof Properties extends string | number ? `${keyof Properties}` : never, Result extends TSchema[] = Key extends PropertyKey ? [Properties[Key]] : []> = Result;
+type TSelectProperty<Properties extends TProperties, Key extends string, CanonicalKey extends string = keyof Properties extends string | number ? `${keyof Properties}` : never, Result extends TSchema[] = Key extends CanonicalKey ? [Properties[Key]] : []> = Result;
 type TSelectProperties<Properties extends TProperties, Keys extends string[], Result extends TSchema[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? TSelectProperties<Properties, Right, [...Result, ...TSelectProperty<Properties, Left>]> : Result);
-export type TFromObject<Properties extends TProperties, Indexer extends TSchema, Keys extends string[] = TToIndexableKeys<Indexer>, Variants extends TSchema[] = TSelectProperties<Properties, Keys>, Result extends TSchema = TEvaluateUnion<Variants>> = Result;
+type TFromIndexer<Properties extends TProperties, Indexer extends TSchema, Keys extends string[] = TToIndexableKeys<Indexer>, Variants extends TSchema[] = TSelectProperties<Properties, Keys>, Result extends TSchema = TEvaluateUnion<Variants>> = Result;
+type TNumericKeys<Keys extends string[], Result extends string[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends `${infer _ extends number}` ? TNumericKeys<Right, [...Result, Left]> : TNumericKeys<Right, Result> : Result);
+type TFromIndexerNumber<Properties extends TProperties, Keys extends string[] = TPropertyKeys<Properties>, NumericKeys extends string[] = TNumericKeys<Keys>, Variants extends TSchema[] = TSelectProperties<Properties, NumericKeys>, Result extends TSchema = TEvaluateUnion<Variants>> = Result;
+export type TFromObject<Properties extends TProperties, Indexer extends TSchema, Result extends TSchema = Indexer extends TNumber ? TFromIndexerNumber<Properties> : TFromIndexer<Properties, Indexer>> = Result;
 export declare function FromObject<Properties extends TProperties, Indexer extends TSchema>(properties: Properties, indexer: Indexer): TFromObject<Properties, Indexer>;
 export {};

package/build/type/engine/indexed/from-object.mjs

@@ -1,18 +1,37 @@
 // deno-fmt-ignore-file
+import { IsNumber } from '../../types/number.mjs';
+import { PropertyKeys } from '../../types/properties.mjs';
 import { EvaluateUnion } from '../evaluate/evaluate.mjs';
 import { ToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
-function SelectProperty(properties, indexer) {
-    const result = indexer in properties ? [properties[indexer]] : [];
+import { IntegerKey } from '../../types/record.mjs';
+function SelectProperty(properties, key) {
+    const result = key in properties ? [properties[key]] : [];
     return result;
 }
-function SelectProperties(properties, indexer) {
-    return indexer.reduce((result, left) => {
+function SelectProperties(properties, keys) {
+    return keys.reduce((result, left) => {
         return [...result, ...SelectProperty(properties, left)];
     }, []);
 }
-export function FromObject(properties, indexer) {
+function FromIndexer(properties, indexer) {
     const keys = ToIndexableKeys(indexer);
     const variants = SelectProperties(properties, keys);
     const result = EvaluateUnion(variants);
     return result;
 }
+const NumericKeyPattern = new RegExp(IntegerKey);
+function NumericKeys(keys) {
+    const result = keys.filter(key => NumericKeyPattern.test(key));
+    return result;
+}
+function FromIndexerNumber(properties) {
+    const keys = PropertyKeys(properties);
+    const numericKeys = NumericKeys(keys);
+    const variants = SelectProperties(properties, numericKeys);
+    const result = EvaluateUnion(variants);
+    return result;
+}
+export function FromObject(properties, indexer) {
+    const result = IsNumber(indexer) ? FromIndexerNumber(properties) : FromIndexer(properties, indexer);
+    return result;
+}

package/build/type/engine/mapped/mapped-variants.d.mts

@@ -1,5 +1,5 @@
 import { type TSchema } from '../../types/index.mjs';
-import { type TLiteral } from '../../types/literal.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
 import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
 import { type TTemplateLiteral } from '../../types/template-literal.mjs';
 import { type TUnion } from '../../types/union.mjs';
@@ -7,7 +7,8 @@ import { type TEnumValuesToVariants } from '../enum/index.mjs';
 import { type TTemplateLiteralDecode } from '../template-literal/decode.mjs';
 type TFromTemplateLiteral<Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema[] = TFromType<Decoded>> = Result;
 type TFromUnion<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, ...TFromType<Left>]> : Result);
-type TFromType<Type extends TSchema, Result extends TSchema[] = (Type extends TEnum<infer Values extends TEnumValue[]> ? TFromUnion<TEnumValuesToVariants<Values>> : Type extends TLiteral<string | number> ? [Type] : Type extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
+type TFromLiteral<Value extends TLiteralValue, Result extends TSchema[] = Value extends number ? [TLiteral<`${Value}`>] : [TLiteral<Value>]> = Result;
+type TFromType<Type extends TSchema, Result extends TSchema[] = (Type extends TEnum<infer Values extends TEnumValue[]> ? TFromUnion<TEnumValuesToVariants<Values>> : Type extends TLiteral<infer Value extends number> ? TFromLiteral<Value> : Type extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
     Type
 ])> = Result;
 export type TMappedVariants<Type extends TSchema, Result extends TSchema[] = TFromType<Type>> = Result;

package/build/type/engine/mapped/mapped-variants.mjs

@@ -1,5 +1,6 @@
 // deno-fmt-ignore-file
-import { IsLiteralNumber, IsLiteralString } from '../../types/literal.mjs';
+import { Guard } from '../../../guard/index.mjs';
+import { Literal, IsLiteral } from '../../types/literal.mjs';
 import { IsEnum } from '../../types/enum.mjs';
 import { IsTemplateLiteral } from '../../types/template-literal.mjs';
 import { IsUnion } from '../../types/union.mjs';
@@ -15,9 +16,13 @@ function FromUnion(types) {
         return [...result, ...FromType(left)];
     }, []);
 }
+function FromLiteral(value) {
+    const result = Guard.IsNumber(value) ? [Literal(`${value}`)] : [Literal(value)];
+    return result;
+}
 function FromType(type) {
     const result = (IsEnum(type) ? FromUnion(EnumValuesToVariants(type.enum)) :
-        IsLiteralString(type) || IsLiteralNumber(type) ? [type] :
+        IsLiteral(type) ? FromLiteral(type.const) :
             IsTemplateLiteral(type) ? FromTemplateLiteral(type.pattern) :
                 IsUnion(type) ? FromUnion(type.anyOf) :
                     [type]);

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

@@ -1,11 +1,13 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TCyclic } from '../types/cyclic.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import { type TUnsafe } from '../types/unsafe.mjs';
 import { type TExtendsLeft } from './extends-left.mjs';
 import { type TCyclicExtends } from '../engine/cyclic/index.mjs';
-type TNormal<Type extends TSchema> = (Type extends TCyclic ? TCyclicExtends<Type> : Type);
+type TCanonical<Type extends TSchema> = (Type extends TCyclic ? TCyclicExtends<Type> : Type extends TUnsafe ? TUnknown : Type);
 /** Performs a structural extends check on left and right types and yields inferred types on right if specified. */
-export type TExtends<Inferred extends TProperties, Left extends TSchema, Right extends TSchema, NormalLeft extends TSchema = TNormal<Left>, NormalRight extends TSchema = TNormal<Right>> = TExtendsLeft<Inferred, NormalLeft, NormalRight>;
+export type TExtends<Inferred extends TProperties, Left extends TSchema, Right extends TSchema, CanonicalLeft extends TSchema = TCanonical<Left>, CanonicalRight extends TSchema = TCanonical<Right>> = TExtendsLeft<Inferred, CanonicalLeft, CanonicalRight>;
 /** Performs a structural extends check on left and right types and yields inferred types on right if specified. */
 export declare function Extends<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtends<Inferred, Left, Right>;
 export {};

package/build/type/extends/extends.mjs

@@ -1,15 +1,17 @@
 // deno-fmt-ignore-file
 import { IsCyclic } from '../types/cyclic.mjs';
+import { Unknown } from '../types/unknown.mjs';
+import { IsUnsafe } from '../types/unsafe.mjs';
 import { ExtendsLeft } from './extends-left.mjs';
 import { CyclicExtends } from '../engine/cyclic/index.mjs';
-function Normal(type) {
-    return (IsCyclic(type)
-        ? CyclicExtends(type)
-        : type);
+function Canonical(type) {
+    return (IsCyclic(type) ? CyclicExtends(type) :
+        IsUnsafe(type) ? Unknown() :
+            type);
 }
 /** Performs a structural extends check on left and right types and yields inferred types on right if specified. */
 export function Extends(inferred, left, right) {
-    const normalLeft = Normal(left);
-    const normalRight = Normal(right);
-    return ExtendsLeft(inferred, normalLeft, normalRight);
+    const canonicalLeft = Canonical(left);
+    const canonicalRight = Canonical(right);
+    return ExtendsLeft(inferred, canonicalLeft, canonicalRight);
 }

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

@@ -8,12 +8,19 @@ export declare function RefineAdd<Type extends TSchema>(type: Type, refinement:
 export type TRefine<Type extends TSchema = TSchema> = (Type & {
     '~refine': TRefinement<Type>[];
 });
-export type TRefineCallback<Type extends TSchema> = (value: Static<Type>) => boolean;
+export type TRefineCheckCallback<Type extends TSchema = TSchema> = (value: Static<Type>) => boolean;
+export type TRefineErrorCallback<Type extends TSchema = TSchema> = (value: Static<Type>) => string;
 export interface TRefinement<Type extends TSchema = TSchema> {
-    refine: TRefineCallback<Type>;
-    message: string;
+    check: TRefineCheckCallback<Type>;
+    error: TRefineErrorCallback<Type>;
 }
-/** Applies a Refine check to the given type. */
-export declare function Refine<Type extends TSchema>(type: Type, refine: TRefineCallback<Type>, message?: string): TRefineAdd<Type>;
+/** Refines a type with an explicit check */
+export declare function Refine<Type extends TSchema>(type: Type, check: TRefineCheckCallback<Type>, error: TRefineErrorCallback<Type>): TRefineAdd<Type>;
+/** Refines a type with an explicit check */
+export declare function Refine<Type extends TSchema>(type: Type, check: TRefineCheckCallback<Type>): TRefineAdd<Type>;
+/** @deprecated Use the error callback signature to generate error message. This overload will be removed in the next version  */
+export declare function Refine<Type extends TSchema>(type: Type, check: TRefineCheckCallback<Type>, message: string): TRefineAdd<Type>;
+/** Returns true if the given value is a TRefinement. */
+export declare function IsRefinement(value: unknown): value is TRefinement;
 /** Returns true if the given value is a TRefine. */
-export declare function IsRefine(value: unknown): value is TRefine<TSchema>;
+export declare function IsRefine(value: unknown): value is TRefine;

package/build/type/types/_refine.mjs

@@ -1,4 +1,5 @@
 // deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
 import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { IsSchema } from './schema.mjs';
@@ -7,14 +8,30 @@ export function RefineAdd(type, refinement) {
     const refinements = IsRefine(type) ? [...type['~refine'], refinement] : [refinement];
     return Memory.Update(type, { '~refine': refinements }, {});
 }
-/** Applies a Refine check to the given type. */
-export function Refine(type, refine, message = 'error') {
-    return RefineAdd(type, { refine, message });
+/** Refines a type with an explicit check */
+export function Refine(...args) {
+    const [type, check, error_or_message] = Arguments.Match(args, {
+        3: (type, check, error) => [type, check, error],
+        2: (type, check) => [type, check, () => 'Refine Error'],
+    });
+    const error = Guard.IsString(error_or_message) ? () => error_or_message : error_or_message;
+    return RefineAdd(type, { check, error });
 }
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------
+/** Returns true if the given value is a TRefinement. */
+export function IsRefinement(value) {
+    return Guard.IsObjectNotArray(value)
+        && Guard.HasPropertyKey(value, 'check')
+        && Guard.HasPropertyKey(value, 'error')
+        && Guard.IsFunction(value.check)
+        && Guard.IsFunction(value.error);
+}
 /** Returns true if the given value is a TRefine. */
 export function IsRefine(value) {
-    return IsSchema(value) && Guard.HasPropertyKey(value, '~refine');
+    return IsSchema(value)
+        && Guard.HasPropertyKey(value, '~refine')
+        && Guard.IsArray(value['~refine'])
+        && Guard.Every(value['~refine'], 0, value => IsRefinement(value));
 }

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

@@ -27,8 +27,6 @@ export interface TRecord<Key extends string = string, Value extends TSchema = TS
 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>;
-/** Returns true if this value is a deferred Interface action. */
-export declare function IsRecordDeferred(value: unknown): value is TRecordDeferred;
 /** Creates a Record type. */
 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. */

package/build/type/types/record.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';
-import { IsKind, IsSchema } from './schema.mjs';
+import { IsKind } from './schema.mjs';
 import { Integer, IntegerPattern } from './integer.mjs';
 import { Number, NumberPattern } from './number.mjs';
 import { String, StringPattern } from './string.mjs';
@@ -16,15 +16,6 @@ export const StringKey = `^${StringPattern}$`;
 export function RecordDeferred(key, value, options = {}) {
     return Deferred('Record', [key, value], options);
 }
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if this value is a deferred Interface action. */
-export function IsRecordDeferred(value) {
-    return IsSchema(value)
-        && Guard.HasPropertyKey(value, 'action')
-        && Guard.IsEqual(value.action, 'Record');
-}
 // -------------------------------------------------------------------
 // Factory
 // -------------------------------------------------------------------

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

@@ -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';

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.28",
+  "version": "1.1.29",
   "keywords": [
     "typescript",
     "jsonschema"