typebox 1.0.75 → 1.0.77

package/build/type/engine/evaluate/distribute.d.mts

@@ -7,16 +7,7 @@ import { type TNarrow } from './narrow.mjs';
 import { type TEvaluateType } from './evaluate.mjs';
 import { type TEvaluateIntersect } from './evaluate.mjs';
 type TIsObjectLike<Type extends TSchema> = Type extends TObject | TTuple ? true : false;
-type TIsUnionOperand<Left extends TSchema, Right extends TSchema, IsUnionLeft extends boolean = Left extends TUnion ? true : false, IsUnionRight extends boolean = Right extends TUnion ? true : false, Result extends boolean = ([
-    IsUnionLeft,
-    IsUnionRight
-] extends [true, true] ? true : [
-    IsUnionLeft,
-    IsUnionRight
-] extends [false, true] ? true : [
-    IsUnionLeft,
-    IsUnionRight
-] extends [true, false] ? true : false)> = Result;
+type TIsUnionOperand<Left extends TSchema, Right extends TSchema, IsUnionLeft extends boolean = Left extends TUnion ? true : false, IsUnionRight extends boolean = Right extends TUnion ? true : false, Result extends boolean = IsUnionLeft extends true ? true : IsUnionRight extends true ? true : false> = Result;
 type TDistributeOperation<Left extends TSchema, Right extends TSchema, EvaluatedLeft extends TSchema = TEvaluateType<Left>, EvaluatedRight extends TSchema = TEvaluateType<Right>, IsUnionOperand extends boolean = TIsUnionOperand<EvaluatedLeft, EvaluatedRight>, IsObjectLeft extends boolean = TIsObjectLike<EvaluatedLeft>, IsObjectRight extends boolean = TIsObjectLike<EvaluatedRight>, Result extends TSchema = ([
     IsUnionOperand
 ] extends [true] ? TEvaluateIntersect<[EvaluatedLeft, EvaluatedRight]> : [

package/build/type/engine/evaluate/distribute.mjs

@@ -15,10 +15,8 @@ function IsObjectLike(type) {
 function IsUnionOperand(left, right) {
     const isUnionLeft = IsUnion(left);
     const isUnionRight = IsUnion(right);
-    return (isUnionLeft && isUnionRight ? true :
-        !isUnionLeft && isUnionRight ? true :
-            isUnionLeft && !isUnionRight ? true :
-                false);
+    const result = isUnionLeft || isUnionRight;
+    return result;
 }
 function DistributeOperation(left, right) {
     const evaluatedLeft = EvaluateType(left);

package/build/type/engine/patterns/pattern.d.mts

@@ -1,7 +1,6 @@
-import { type TUnreachable } from '../../../system/unreachable/index.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TPattern } from '../../script/parser.mjs';
-/** Parses a Pattern into a sequence of TemplateLiteral types */
-export type TParsePatternIntoTypes<Pattern extends string, Parsed extends [TSchema[], string] | [] = TPattern<Pattern>, Result extends TSchema[] = Parsed extends [infer Types extends TSchema[], string] ? Types : TUnreachable> = Result;
-/** Parses a Pattern into a sequence of TemplateLiteral types */
+/** Parses a Pattern into a sequence of TemplateLiteral types. A result of [] indicates failure to parse. */
+export type TParsePatternIntoTypes<Pattern extends string, Parsed extends [TSchema[], string] | [] = TPattern<Pattern>, Result extends TSchema[] = Parsed extends [infer Types extends TSchema[], string] ? Types : []> = Result;
+/** Parses a Pattern into a sequence of TemplateLiteral types. A result of [] indicates failure to parse. */
 export declare function ParsePatternIntoTypes<Pattern extends string>(pattern: Pattern): TParsePatternIntoTypes<Pattern>;

package/build/type/engine/patterns/pattern.mjs

@@ -1,13 +1,11 @@
 // deno-fmt-ignore-file
-import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
 import { Pattern } from '../../script/parser.mjs';
-/** Parses a Pattern into a sequence of TemplateLiteral types */
+/** Parses a Pattern into a sequence of TemplateLiteral types. A result of [] indicates failure to parse. */
 export function ParsePatternIntoTypes(pattern) {
     const parsed = Pattern(pattern);
     const result = Guard.IsEqual(parsed.length, 2)
         ? parsed[0]
-        : Unreachable(); // []
+        : []; // Failed to Parse
     return result;
 }
-// deno-coverage-ignore-stop

package/build/type/engine/record/from-key-template-literal.d.mts

@@ -2,7 +2,7 @@ import { type TSchema } from '../../types/schema.mjs';
 import { type TRecord } from '../../types/record.mjs';
 import { type TFromKey } from './from-key.mjs';
 import { type TParsePatternIntoTypes } from '../patterns/pattern.mjs';
-import { type TTemplateLiteralFinite } from '../template-literal/finite.mjs';
+import { type TIsTemplateLiteralFinite } from '../template-literal/is-finite.mjs';
 import { type TTemplateLiteralDecode } from '../template-literal/decode.mjs';
-export type TFromTemplateKey<Pattern extends string, Value extends TSchema, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>, Finite extends boolean = TTemplateLiteralFinite<Types>, Result extends TSchema = Finite extends true ? TFromKey<TTemplateLiteralDecode<Pattern>, Value> : TRecord<Pattern, Value>> = Result;
+export type TFromTemplateKey<Pattern extends string, Value extends TSchema, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>, Finite extends boolean = TIsTemplateLiteralFinite<Types>, Result extends TSchema = Finite extends true ? TFromKey<TTemplateLiteralDecode<Pattern>, Value> : TRecord<Pattern, Value>> = Result;
 export declare function FromTemplateKey<Pattern extends string, Value extends TSchema>(pattern: Pattern, value: Value): TFromTemplateKey<Pattern, Value>;

package/build/type/engine/record/from-key-template-literal.mjs

@@ -1,12 +1,12 @@
 // deno-fmt-ignore-file
 import { FromKey } from './from-key.mjs';
 import { ParsePatternIntoTypes } from '../patterns/pattern.mjs';
-import { TemplateLiteralFinite } from '../template-literal/finite.mjs';
+import { IsTemplateLiteralFinite } from '../template-literal/is-finite.mjs';
 import { TemplateLiteralDecode } from '../template-literal/decode.mjs';
 import { CreateRecord } from './record-create.mjs';
 export function FromTemplateKey(pattern, value) {
     const types = ParsePatternIntoTypes(pattern);
-    const finite = TemplateLiteralFinite(types);
+    const finite = IsTemplateLiteralFinite(types);
     const result = finite ? FromKey(TemplateLiteralDecode(pattern), value) : CreateRecord(pattern, value);
     return result;
 }

package/build/type/engine/template-literal/decode.d.mts

@@ -1,10 +1,11 @@
 import { TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
 import { type TSchema } from '../../types/schema.mjs';
-import { type TUnion } from '../../types/union.mjs';
 import { type TString } from '../../types/string.mjs';
-import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TTemplateLiteral } from '../../types/template-literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
 import { type TParsePatternIntoTypes } from '../patterns/pattern.mjs';
-import { type TTemplateLiteralFinite } from './finite.mjs';
+import { type TIsTemplateLiteralFinite } from './is-finite.mjs';
 type TFromLiteralPush<Variants extends string[], Value extends TLiteralValue, Result extends string[] = []> = Variants extends [infer Left extends string, ...infer Right extends string[]] ? TFromLiteralPush<Right, Value, [...Result, `${Left}${Value}`]> : Result;
 type TFromLiteral<Variants extends string[], Value extends TLiteralValue> = Variants extends [] ? [`${Value}`] : TFromLiteralPush<Variants, Value>;
 type TFromUnion<Variants extends string[], Types extends TSchema[], Result extends string[] = []> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Variants, Right, [...Result, ...TFromType<Variants, Left>]> : Result;
@@ -13,8 +14,17 @@ type TDecodeFromSpan<Variants extends string[], Types extends TSchema[]> = Types
 type TVariantsToLiterals<Variants extends string[], Result extends TSchema[] = []> = Variants extends [infer Left extends string, ...infer Right extends string[]] ? TVariantsToLiterals<Right, [...Result, TLiteral<Left>]> : Result;
 type TDecodeTypesAsUnion<Types extends TSchema[], Variants extends string[] = TDecodeFromSpan<[], Types>, Literals extends TSchema[] = TVariantsToLiterals<Variants>, Result extends TSchema = TUnion<Literals>> = Result;
 type TDecodeTypes<Types extends TSchema[], Result extends TSchema = (Types extends [] ? TUnreachable : Types extends [infer Type extends TLiteral] ? Type : TDecodeTypesAsUnion<Types>)> = Result;
-/** Decodes a TemplateLiteral into a Type. If the TemplateLiteral yields a non-finite set, the return value is TString */
-export type TTemplateLiteralDecode<Pattern extends string, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>, Finite extends boolean = TTemplateLiteralFinite<Types>, Result extends TSchema = (Finite extends true ? TDecodeTypes<Types> : TString)> = Result;
-/** Decodes a TemplateLiteral into a Type. If the TemplateLiteral yields a non-finite set, the return value is TString */
+/** Decodes a TemplateLiteral into a Type. */
+export type TTemplateLiteralDecodeUnsafe<Pattern extends string, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>, Result extends TSchema = (Types extends [] ? TString : TIsTemplateLiteralFinite<Types> extends true ? TDecodeTypes<Types> : TTemplateLiteral<Pattern>)> = Result;
+/**
+ * (Internal) Decodes a TemplateLiteral pattern into a Type. This function is unsafe. Decoding a non-finite
+ * TemplateLiteral pattern may produce another TemplateLiteral pattern. During enumeration, this
+ * TemplateLiteral -> TemplateLiteral behavior can cause a StackOverflow. A better in-flight template-literal
+ * decoding algorithm is needed. (for review)
+ */
+export declare function TemplateLiteralDecodeUnsafe<Pattern extends string>(pattern: Pattern): TTemplateLiteralDecodeUnsafe<Pattern>;
+/** Decodes a TemplateLiteral pattern but returns TString if the pattern in non-finite. */
+export type TTemplateLiteralDecode<Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecodeUnsafe<Pattern>, Result extends TSchema = Decoded extends TTemplateLiteral ? TString : Decoded> = Result;
+/** Decodes a TemplateLiteral pattern but returns TString if the pattern in non-finite. */
 export declare function TemplateLiteralDecode<Pattern extends string>(pattern: Pattern): TTemplateLiteralDecode<Pattern>;
 export {};

package/build/type/engine/template-literal/decode.mjs

@@ -1,12 +1,14 @@
 // deno-fmt-ignore-file
 import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
+import { Literal, IsLiteral } from '../../types/literal.mjs';
 import { IsSchema } from '../../types/schema.mjs';
-import { Union, IsUnion } from '../../types/union.mjs';
 import { String } from '../../types/string.mjs';
-import { Literal, IsLiteral } from '../../types/literal.mjs';
+import { IsTemplateLiteral } from '../../types/template-literal.mjs';
+import { Union, IsUnion } from '../../types/union.mjs';
 import { ParsePatternIntoTypes } from '../patterns/pattern.mjs';
-import { TemplateLiteralFinite } from './finite.mjs';
+import { IsTemplateLiteralFinite } from './is-finite.mjs';
+import { TemplateLiteralCreate } from './create.mjs';
 function FromLiteralPush(variants, value, result = []) {
     const [left, ...right] = variants;
     return (Guard.IsString(left) ? FromLiteralPush(right, value, [...result, `${left}${value}`]) : result);
@@ -62,12 +64,24 @@ function DecodeTypes(types) {
         Guard.IsEqual(types.length, 1) && IsLiteral(types[0]) ? types[0] :
             DecodeTypesAsUnion(types));
 }
-/** Decodes a TemplateLiteral into a Type. If the TemplateLiteral yields a non-finite set, the return value is TString */
-export function TemplateLiteralDecode(pattern) {
+/**
+ * (Internal) Decodes a TemplateLiteral pattern into a Type. This function is unsafe. Decoding a non-finite
+ * TemplateLiteral pattern may produce another TemplateLiteral pattern. During enumeration, this
+ * TemplateLiteral -> TemplateLiteral behavior can cause a StackOverflow. A better in-flight template-literal
+ * decoding algorithm is needed. (for review)
+ */
+export function TemplateLiteralDecodeUnsafe(pattern) {
     const types = ParsePatternIntoTypes(pattern);
-    const finite = TemplateLiteralFinite(types);
-    const result = finite
-        ? DecodeTypes(types)
-        : String();
+    const result = Guard.IsEqual(types.length, 0) // Failed to Parse | IsTemplateLiteralPattern
+        ? String() // ... Pattern cannot be typed, so discard
+        : IsTemplateLiteralFinite(types)
+            ? DecodeTypes(types)
+            : TemplateLiteralCreate(pattern);
+    return result;
+}
+/** Decodes a TemplateLiteral pattern but returns TString if the pattern in non-finite. */
+export function TemplateLiteralDecode(pattern) {
+    const decoded = TemplateLiteralDecodeUnsafe(pattern);
+    const result = IsTemplateLiteral(decoded) ? String() : decoded;
     return result;
 }

package/build/type/engine/template-literal/index.d.mts

@@ -1,5 +1,6 @@
 export * from './create.mjs';
 export * from './decode.mjs';
 export * from './encode.mjs';
-export * from './finite.mjs';
 export * from './static.mjs';
+export * from './is-finite.mjs';
+export * from './is-pattern.mjs';

package/build/type/engine/template-literal/index.mjs

@@ -1,5 +1,6 @@
 export * from './create.mjs';
 export * from './decode.mjs';
 export * from './encode.mjs';
-export * from './finite.mjs';
 export * from './static.mjs';
+export * from './is-finite.mjs';
+export * from './is-pattern.mjs';

package/build/type/engine/template-literal/{finite.d.mts → is-finite.d.mts}

@@ -6,7 +6,7 @@ type TFromTypesReduce<Types extends TSchema[]> = (Types extends [infer Left exte
 type TFromTypes<Types extends TSchema[], Result extends boolean = Types extends [] ? false : TFromTypesReduce<Types>> = Result;
 type TFromType<Type extends TSchema> = Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : false;
 /** Returns true if the given TemplateLiteral types yields a finite variant set */
-export type TTemplateLiteralFinite<Types extends TSchema[], Result extends boolean = TFromTypes<Types>> = Result;
+export type TIsTemplateLiteralFinite<Types extends TSchema[], Result extends boolean = TFromTypes<Types>> = Result;
 /** Returns true if the given TemplateLiteral types yields a finite variant set */
-export declare function TemplateLiteralFinite<Types extends TSchema[]>(types: [...Types]): TTemplateLiteralFinite<Types>;
+export declare function IsTemplateLiteralFinite<Types extends TSchema[]>(types: [...Types]): TIsTemplateLiteralFinite<Types>;
 export {};

package/build/type/engine/template-literal/{finite.mjs → is-finite.mjs}

@@ -24,7 +24,7 @@ function FromType(type) {
             false);
 }
 /** Returns true if the given TemplateLiteral types yields a finite variant set */
-export function TemplateLiteralFinite(types) {
+export function IsTemplateLiteralFinite(types) {
     const result = FromTypes(types);
     return result;
 }

package/build/type/engine/template-literal/is-pattern.d.mts

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TParsePatternIntoTypes } from '../patterns/pattern.mjs';
+/** Returns true if this pattern is a valid Template Literal regular expression */
+export type TIsTemplateLiteralPattern<Pattern extends string, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>, Result extends boolean = Types extends [] ? false : true> = Result;
+/** Returns true if this pattern is a valid Template Literal regular expression */
+export declare function IsTemplateLiteralPattern<Pattern extends string>(pattern: Pattern): TIsTemplateLiteralPattern<Pattern>;

package/build/type/engine/template-literal/is-pattern.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { ParsePatternIntoTypes } from '../patterns/pattern.mjs';
+/** Returns true if this pattern is a valid Template Literal regular expression */
+export function IsTemplateLiteralPattern(pattern) {
+    const types = ParsePatternIntoTypes(pattern);
+    const result = Guard.IsEqual(types.length, 0) ? false : true;
+    return result;
+}

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

@@ -7,6 +7,7 @@ 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';
 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>> = Record<StaticKey, StaticValue>;
 export type TStringKey = typeof StringKey;
@@ -37,7 +38,7 @@ export type TRecordPattern<Type extends TRecord, Result extends string = Extract
 /** Returns the raw string pattern used for the Record key  */
 export declare function RecordPattern<Type extends TRecord>(type: Type): TRecordPattern<Type>;
 /** Returns the Record key as a TypeBox type  */
-export type TRecordKey<Type extends TRecord, Pattern extends string = TRecordPattern<Type>, Result extends TSchema = (Pattern extends typeof IntegerKey ? TInteger : Pattern extends typeof NumberKey ? TNumber : TString)> = Result;
+export type TRecordKey<Type extends TRecord, Pattern extends string = TRecordPattern<Type>, Result extends TSchema = (Pattern extends typeof StringKey ? TString : Pattern extends typeof IntegerKey ? TInteger : Pattern extends typeof NumberKey ? TNumber : TTemplateLiteralDecodeUnsafe<Pattern>)> = Result;
 /** Returns the Record key as a TypeBox type  */
 export declare function RecordKey<Type extends TRecord>(type: Type): TRecordKey<Type>;
 export type TRecordValue<Type extends TRecord, Result extends TSchema = Type['patternProperties'][TRecordPattern<Type>]> = Result;

package/build/type/types/record.mjs

@@ -7,6 +7,7 @@ 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';
 export const IntegerKey = `^${IntegerPattern}$`;
 export const NumberKey = `^${NumberPattern}$`;
@@ -39,9 +40,10 @@ export function RecordPattern(type) {
 /** Returns the Record key as a TypeBox type  */
 export function RecordKey(type) {
     const pattern = RecordPattern(type);
-    const result = (Guard.IsEqual(pattern, IntegerKey) ? Integer() :
-        Guard.IsEqual(pattern, NumberKey) ? Number() :
-            String());
+    const result = (Guard.IsEqual(pattern, StringKey) ? String() :
+        Guard.IsEqual(pattern, IntegerKey) ? Integer() :
+            Guard.IsEqual(pattern, NumberKey) ? Number() :
+                TemplateLiteralDecodeUnsafe(pattern));
     return result;
 }
 export function RecordValue(type) {

package/package.json

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

package/readme.md

@@ -25,7 +25,7 @@ $ npm install typebox
 
 ## Usage
 
-A TypeScript first validation engine for JSON Schema [Example](https://tsplay.dev/mZMOeN)
+A TypeScript engine for JSON Schema [Example](https://tsplay.dev/mZMOeN)
 
 ```typescript
 import Type from 'typebox'
@@ -212,7 +212,7 @@ type S = Type.Static<typeof S>                      // type S = {
 
 [Documentation](https://sinclairzx81.github.io/typebox/#/docs/compile/overview) | [Example](https://tsplay.dev/WyraZw)
 
-The Compile submodule is a high-performance JSON Schema compliant JIT compiler that compiles schematics into efficient runtime validators. The compiler is optimized for fast compilation and validation and is known to be one of the fastest validation solutions available for JavaScript.
+The Compile submodule is a high-performance, JSON Schema compliant JIT compiler that transforms schematics into efficient runtime validators. It is optimized for fast, dynamic schema compilation and delivers extremely high data-validation throughput.
 
 ```typescript
 import Compile from 'typebox/compile'