@sinclair/typebox 0.32.0-dev-19 → 0.32.0-dev-21

package/build/import/index.mjs

@@ -42,12 +42,12 @@ export { Null } from './type/null/index.mjs';
 export { Number } from './type/number/index.mjs';
 export { Object } from './type/object/index.mjs';
 export { Omit } from './type/omit/index.mjs';
-export { Optional } from './type/optional/index.mjs';
+export { Optional, OptionalFromMappedResult } from './type/optional/index.mjs';
 export { Parameters } from './type/parameters/index.mjs';
 export { Partial, PartialFromMappedResult } from './type/partial/index.mjs';
 export { Pick } from './type/pick/index.mjs';
 export { Promise } from './type/promise/index.mjs';
-export { Readonly } from './type/readonly/index.mjs';
+export { Readonly, ReadonlyFromMappedResult } from './type/readonly/index.mjs';
 export { ReadonlyOptional } from './type/readonly-optional/index.mjs';
 export { Record } from './type/record/index.mjs';
 export { Recursive } from './type/recursive/index.mjs';
@@ -59,7 +59,7 @@ export { ReturnType } from './type/return-type/index.mjs';
 export { Strict } from './type/strict/index.mjs';
 export { String } from './type/string/index.mjs';
 export { Symbol } from './type/symbol/index.mjs';
-export { TemplateLiteral, IsTemplateLiteralFinite, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralGenerate } from './type/template-literal/index.mjs';
+export { TemplateLiteral, IsTemplateLiteralFinite, IsTemplateLiteralExpressionFinite, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralGenerate, TemplateLiteralExpressionGenerate, } from './type/template-literal/index.mjs';
 export { Transform, TransformDecodeBuilder, TransformEncodeBuilder } from './type/transform/index.mjs';
 export { Tuple } from './type/tuple/index.mjs';
 export { Uint8Array } from './type/uint8array/index.mjs';

package/build/import/type/indexed/indexed-property-keys.d.mts

@@ -1,10 +1,10 @@
-import { type TTemplateLiteral, TemplateLiteralGenerate, IsTemplateLiteralFinite } from '../template-literal/index.mjs';
+import { type TTemplateLiteral, TTemplateLiteralGenerate } from '../template-literal/index.mjs';
 import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TInteger } from '../integer/index.mjs';
 import { type TNumber } from '../number/index.mjs';
 import { type TSchema } from '../schema/index.mjs';
 import { type TUnion } from '../union/index.mjs';
-type FromTemplateLiteral<T extends TTemplateLiteral, F = IsTemplateLiteralFinite<T>> = (F extends true ? TemplateLiteralGenerate<T> extends infer R extends string[] ? R : [] : []);
+type FromTemplateLiteral<T extends TTemplateLiteral, R extends string[] = TTemplateLiteralGenerate<T>> = (R);
 declare function FromTemplateLiteral<T extends TTemplateLiteral>(T: T): FromTemplateLiteral<T>;
 type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [...TIndexPropertyKeys<L>, ...FromUnion<R>] : []);
 declare function FromUnion<T extends TSchema[]>(T: T): FromUnion<T>;

package/build/import/type/indexed/indexed-property-keys.mjs

@@ -1,19 +1,13 @@
-import { TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralToUnion } from '../template-literal/index.mjs';
+import { TemplateLiteralGenerate } from '../template-literal/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { IsTemplateLiteral, IsUnionLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from '../guard/type.mjs';
+import { IsTemplateLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from '../guard/type.mjs';
 // prettier-ignore
 function FromTemplateLiteral(T) {
-    const E = TemplateLiteralParseExact(T.pattern);
-    const F = IsTemplateLiteralFinite(E);
-    const S = TemplateLiteralToUnion(T);
-    return (F === true
-        ? IsUnionLiteral(S)
-            ? S.anyOf.map(S => S.const.toString())
-            : []
-        : []);
+    const R = TemplateLiteralGenerate(T);
+    return R.map(S => S.toString());
 }
 // prettier-ignore
 function FromUnion(T) {
@@ -24,7 +18,8 @@ function FromUnion(T) {
 }
 // prettier-ignore
 function FromLiteral(T) {
-    return ([T.toString()]);
+    return ([T.toString()] // TS 5.4 observes TLiteralValue as not having a toString()
+    );
 }
 /** Returns a tuple of PropertyKeys derived from the given TSchema */
 // prettier-ignore

package/build/import/type/intrinsic/intrinsic.mjs

@@ -1,4 +1,4 @@
-import { TemplateLiteral, TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralGenerate } from '../template-literal/index.mjs';
+import { TemplateLiteral, TemplateLiteralParseExact, IsTemplateLiteralExpressionFinite, TemplateLiteralExpressionGenerate } from '../template-literal/index.mjs';
 import { IntrinsicFromMappedKey } from './intrinsic-from-mapped-key.mjs';
 import { Literal } from '../literal/index.mjs';
 import { Union } from '../union/index.mjs';
@@ -28,10 +28,10 @@ function FromTemplateLiteral(schema, mode, options) {
     // note: template literals require special runtime handling as they are encoded in string patterns.
     // This diverges from the mapped type which would otherwise map on the template literal kind.
     const expression = TemplateLiteralParseExact(schema.pattern);
-    const finite = IsTemplateLiteralFinite(expression);
+    const finite = IsTemplateLiteralExpressionFinite(expression);
     if (!finite)
         return { ...schema, pattern: FromLiteralValue(schema.pattern, mode) };
-    const strings = [...TemplateLiteralGenerate(expression)];
+    const strings = [...TemplateLiteralExpressionGenerate(expression)];
     const literals = strings.map((value) => Literal(value));
     const mapped = FromRest(literals, mode);
     const union = Union(mapped);

package/build/import/type/optional/index.d.mts

@@ -1 +1,2 @@
+export * from './optional-from-mapped-result.mjs';
 export * from './optional.mjs';

package/build/import/type/optional/index.mjs

@@ -1 +1,2 @@
+export * from './optional-from-mapped-result.mjs';
 export * from './optional.mjs';

package/build/import/type/optional/optional-from-mapped-result.d.mts

@@ -0,0 +1,12 @@
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TOptionalWithFlag } from './optional.mjs';
+type FromProperties<K extends TProperties, F extends boolean> = ({
+    [K2 in keyof K]: TOptionalWithFlag<K[K2], F>;
+});
+declare function FromProperties<K extends TProperties, F extends boolean>(K: K, F: F): FromProperties<K, F>;
+type FromMappedResult<K extends TMappedResult, F extends boolean> = (FromProperties<K['properties'], F>);
+declare function FromMappedResult<K extends TMappedResult, F extends boolean>(K: K, F: F): FromMappedResult<K, F>;
+export type TOptionalFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = FromMappedResult<T, F>> = (TMappedResult<P>);
+export declare function OptionalFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = FromMappedResult<T, F>>(T: T, F: F): TMappedResult<P>;
+export {};

package/build/import/type/optional/optional-from-mapped-result.mjs

@@ -0,0 +1,17 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Optional } from './optional.mjs';
+// prettier-ignore
+function FromProperties(K, F) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Optional(K[K2], F) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedResult(K, F) {
+    return FromProperties(K.properties, F);
+}
+// prettier-ignore
+export function OptionalFromMappedResult(T, F) {
+    const P = FromMappedResult(T, F);
+    return MappedResult(P);
+}

package/build/import/type/optional/optional.d.mts

@@ -1,7 +1,24 @@
 import type { TSchema } from '../schema/index.mjs';
+import type { Ensure } from '../helpers/index.mjs';
 import { OptionalKind } from '../symbols/index.mjs';
+import type { TMappedResult } from '../mapped/index.mjs';
+import { type TOptionalFromMappedResult } from './optional-from-mapped-result.mjs';
+type RemoveOptional<T extends TSchema> = T extends TOptional<infer S> ? S : T;
+declare function RemoveOptional<T extends TSchema>(schema: T): Record<PropertyKey, any>;
+type AddOptional<T extends TSchema> = T extends TOptional<infer S> ? TOptional<S> : Ensure<TOptional<T>>;
+declare function AddOptional<T extends TSchema>(schema: T): T & {
+    [OptionalKind]: string;
+};
+export type TOptionalWithFlag<T extends TSchema, F extends boolean> = F extends false ? RemoveOptional<T> : AddOptional<T>;
 export type TOptional<T extends TSchema> = T & {
     [OptionalKind]: 'Optional';
 };
-/** `[Json]` Creates an Optional property */
-export declare function Optional<T extends TSchema>(schema: T): TOptional<T>;
+/** `[Json]` Creates a Optional property */
+export declare function Optional<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TOptionalFromMappedResult<T, F>;
+/** `[Json]` Creates a Optional property */
+export declare function Optional<T extends TSchema, F extends boolean>(schema: T, enable: F): TOptionalWithFlag<T, F>;
+/** `[Json]` Creates a Optional property */
+export declare function Optional<T extends TMappedResult>(schema: T): TOptionalFromMappedResult<T, true>;
+/** `[Json]` Creates a Optional property */
+export declare function Optional<T extends TSchema>(schema: T): TOptionalWithFlag<T, true>;
+export {};

package/build/import/type/optional/optional.mjs

@@ -1,6 +1,22 @@
 import { OptionalKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
-/** `[Json]` Creates an Optional property */
-export function Optional(schema) {
+import { Discard } from '../discard/index.mjs';
+import { OptionalFromMappedResult } from './optional-from-mapped-result.mjs';
+import { IsMappedResult } from '../guard/type.mjs';
+function RemoveOptional(schema) {
+    return Discard(CloneType(schema), [OptionalKind]);
+}
+function AddOptional(schema) {
     return { ...CloneType(schema), [OptionalKind]: 'Optional' };
 }
+// prettier-ignore
+function OptionalWithFlag(schema, F) {
+    return (F === false
+        ? RemoveOptional(schema)
+        : AddOptional(schema));
+}
+/** `[Json]` Creates a Optional property */
+export function Optional(schema, enable) {
+    const F = enable ?? true;
+    return IsMappedResult(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F);
+}

package/build/import/type/readonly/index.d.mts

@@ -1 +1,2 @@
+export * from './readonly-from-mapped-result.mjs';
 export * from './readonly.mjs';

package/build/import/type/readonly/index.mjs

@@ -1 +1,2 @@
+export * from './readonly-from-mapped-result.mjs';
 export * from './readonly.mjs';

package/build/import/type/readonly/readonly-from-mapped-result.d.mts

@@ -0,0 +1,12 @@
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TReadonlyWithFlag } from './readonly.mjs';
+type FromProperties<K extends TProperties, F extends boolean> = ({
+    [K2 in keyof K]: TReadonlyWithFlag<K[K2], F>;
+});
+declare function FromProperties<K extends TProperties, F extends boolean>(K: K, F: F): FromProperties<K, F>;
+type FromMappedResult<K extends TMappedResult, F extends boolean> = (FromProperties<K['properties'], F>);
+declare function FromMappedResult<K extends TMappedResult, F extends boolean>(K: K, F: F): FromMappedResult<K, F>;
+export type TReadonlyFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = FromMappedResult<T, F>> = (TMappedResult<P>);
+export declare function ReadonlyFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = FromMappedResult<T, F>>(T: T, F: F): TMappedResult<P>;
+export {};

package/build/import/type/readonly/readonly-from-mapped-result.mjs

@@ -0,0 +1,17 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Readonly } from './readonly.mjs';
+// prettier-ignore
+function FromProperties(K, F) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Readonly(K[K2], F) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedResult(K, F) {
+    return FromProperties(K.properties, F);
+}
+// prettier-ignore
+export function ReadonlyFromMappedResult(T, F) {
+    const P = FromMappedResult(T, F);
+    return MappedResult(P);
+}

package/build/import/type/readonly/readonly.d.mts

@@ -1,7 +1,24 @@
 import type { TSchema } from '../schema/index.mjs';
+import type { Ensure } from '../helpers/index.mjs';
 import { ReadonlyKind } from '../symbols/index.mjs';
+import type { TMappedResult } from '../mapped/index.mjs';
+import { type TReadonlyFromMappedResult } from './readonly-from-mapped-result.mjs';
+type RemoveReadonly<T extends TSchema> = T extends TReadonly<infer S> ? S : T;
+declare function RemoveReadonly<T extends TSchema>(schema: T): Record<PropertyKey, any>;
+type AddReadonly<T extends TSchema> = T extends TReadonly<infer S> ? TReadonly<S> : Ensure<TReadonly<T>>;
+declare function AddReadonly<T extends TSchema>(schema: T): T & {
+    [ReadonlyKind]: string;
+};
+export type TReadonlyWithFlag<T extends TSchema, F extends boolean> = F extends false ? RemoveReadonly<T> : AddReadonly<T>;
 export type TReadonly<T extends TSchema> = T & {
     [ReadonlyKind]: 'Readonly';
 };
 /** `[Json]` Creates a Readonly property */
-export declare function Readonly<T extends TSchema>(schema: T): TReadonly<T>;
+export declare function Readonly<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TReadonlyFromMappedResult<T, F>;
+/** `[Json]` Creates a Readonly property */
+export declare function Readonly<T extends TSchema, F extends boolean>(schema: T, enable: F): TReadonlyWithFlag<T, F>;
+/** `[Json]` Creates a Readonly property */
+export declare function Readonly<T extends TMappedResult>(schema: T): TReadonlyFromMappedResult<T, true>;
+/** `[Json]` Creates a Readonly property */
+export declare function Readonly<T extends TSchema>(schema: T): TReadonlyWithFlag<T, true>;
+export {};

package/build/import/type/readonly/readonly.mjs

@@ -1,6 +1,22 @@
 import { ReadonlyKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
-/** `[Json]` Creates a Readonly property */
-export function Readonly(schema) {
+import { Discard } from '../discard/index.mjs';
+import { ReadonlyFromMappedResult } from './readonly-from-mapped-result.mjs';
+import { IsMappedResult } from '../guard/type.mjs';
+function RemoveReadonly(schema) {
+    return Discard(CloneType(schema), [ReadonlyKind]);
+}
+function AddReadonly(schema) {
     return { ...CloneType(schema), [ReadonlyKind]: 'Readonly' };
 }
+// prettier-ignore
+function ReadonlyWithFlag(schema, F) {
+    return (F === false
+        ? RemoveReadonly(schema)
+        : AddReadonly(schema));
+}
+/** `[Json]` Creates a Readonly property */
+export function Readonly(schema, enable) {
+    const F = enable ?? true;
+    return IsMappedResult(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
+}

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

@@ -9,13 +9,13 @@ import { type TString } from '../string/index.mjs';
 import { type TInteger } from '../integer/index.mjs';
 import { type TNumber } from '../number/index.mjs';
 import { type TEnum } from '../enum/index.mjs';
-import { TTemplateLiteral, IsTemplateLiteralFinite } from '../template-literal/index.mjs';
+import { TTemplateLiteral, TIsTemplateLiteralFinite } from '../template-literal/index.mjs';
 import { Kind } from '../symbols/index.mjs';
 type FromTemplateLiteralKeyInfinite<K extends TTemplateLiteral, T extends TSchema> = Ensure<TRecord<K, T>>;
 type FromTemplateLiteralKeyFinite<K extends TTemplateLiteral, T extends TSchema, I extends string = Static<K>> = (Ensure<TObject<Evaluate<{
     [_ in I]: T;
 }>>>);
-type FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends false ? FromTemplateLiteralKeyInfinite<K, T> : FromTemplateLiteralKeyFinite<K, T>;
+type FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = TIsTemplateLiteralFinite<K> extends false ? FromTemplateLiteralKeyInfinite<K, T> : FromTemplateLiteralKeyFinite<K, T>;
 declare function FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema>(K: K, T: T, options: ObjectOptions): FromTemplateLiteralKey<K, T>;
 type FromEnumKey<K extends Record<string, string | number>, T extends TSchema> = Ensure<TObject<{
     [_ in K[keyof K]]: T;

package/build/import/type/record/record.mjs

@@ -1,7 +1,7 @@
 import { Object } from '../object/index.mjs';
 import { Never } from '../never/index.mjs';
 import { Union } from '../union/index.mjs';
-import { IsTemplateLiteralFinite, TemplateLiteralParseExact } from '../template-literal/index.mjs';
+import { IsTemplateLiteralFinite } from '../template-literal/index.mjs';
 import { PatternStringExact, PatternNumberExact } from '../patterns/index.mjs';
 import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Kind, Hint } from '../symbols/index.mjs';
@@ -34,8 +34,7 @@ function RecordCreateFromKeys(K, T, options) {
 }
 // prettier-ignore
 function FromTemplateLiteralKey(K, T, options) {
-    const expression = TemplateLiteralParseExact(K.pattern);
-    return (IsTemplateLiteralFinite(expression)
+    return (IsTemplateLiteralFinite(K)
         ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options)
         : RecordCreateFromPattern(K.pattern, T, options));
 }

package/build/import/type/schema/schema.d.mts

@@ -20,7 +20,7 @@ export interface SchemaOptions {
 export interface TKind {
     [Kind]: string;
 }
-export interface TSchema extends SchemaOptions, TKind {
+export interface TSchema extends TKind, SchemaOptions {
     [ReadonlyKind]?: string;
     [OptionalKind]?: string;
     [Hint]?: string;

package/build/import/type/symbol/symbol.d.mts

@@ -1,6 +1,6 @@
 import { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { Kind } from '../symbols/index.mjs';
-export type SymbolValue = string | number | undefined;
+export type TSymbolValue = string | number | undefined;
 export interface TSymbol extends TSchema, SchemaOptions {
     [Kind]: 'Symbol';
     static: symbol;

package/build/import/type/template-literal/finite.d.mts

@@ -6,11 +6,13 @@ import type { TNumber } from '../number/index.mjs';
 import type { TInteger } from '../integer/index.mjs';
 import type { TBigInt } from '../bigint/index.mjs';
 import type { TLiteral } from '../literal/index.mjs';
-import type { Expression } from './parser.mjs';
+import type { Expression } from './parse.mjs';
 export declare class TemplateLiteralFiniteError extends Error {
 }
-type IsTemplateLiteralFiniteCheck<T> = T extends TTemplateLiteral<infer U extends TTemplateLiteralKind[]> ? IsTemplateLiteralFiniteArray<U> : T extends TUnion<infer U extends TTemplateLiteralKind[]> ? IsTemplateLiteralFiniteArray<U> : T extends TString ? false : T extends TBoolean ? false : T extends TNumber ? false : T extends TInteger ? false : T extends TBigInt ? false : T extends TLiteral ? true : false;
-type IsTemplateLiteralFiniteArray<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? IsTemplateLiteralFiniteCheck<L> extends false ? false : IsTemplateLiteralFiniteArray<R> : true;
-export type IsTemplateLiteralFinite<T> = T extends TTemplateLiteral<infer U> ? IsTemplateLiteralFiniteArray<U> : false;
-export declare function IsTemplateLiteralFinite(expression: Expression): boolean;
+type FromTemplateLiteralKind<T> = T extends TTemplateLiteral<infer U extends TTemplateLiteralKind[]> ? FromTemplateLiteralKinds<U> : T extends TUnion<infer U extends TTemplateLiteralKind[]> ? FromTemplateLiteralKinds<U> : T extends TString ? false : T extends TNumber ? false : T extends TInteger ? false : T extends TBigInt ? false : T extends TBoolean ? true : T extends TLiteral ? true : false;
+type FromTemplateLiteralKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? FromTemplateLiteralKind<L> extends false ? false : FromTemplateLiteralKinds<R> : true;
+export declare function IsTemplateLiteralExpressionFinite(expression: Expression): boolean;
+export type TIsTemplateLiteralFinite<T> = T extends TTemplateLiteral<infer U> ? FromTemplateLiteralKinds<U> : false;
+/** Returns true if this TemplateLiteral resolves to a finite set of values */
+export declare function IsTemplateLiteralFinite<T extends TTemplateLiteral>(schema: T): boolean;
 export {};

package/build/import/type/template-literal/finite.mjs

@@ -1,3 +1,4 @@
+import { TemplateLiteralParseExact } from './parse.mjs';
 // ------------------------------------------------------------------
 // TemplateLiteralFiniteError
 // ------------------------------------------------------------------
@@ -28,12 +29,20 @@ function IsBooleanExpression(expression) {
 function IsStringExpression(expression) {
     return expression.type === 'const' && expression.const === '.*';
 }
+// ------------------------------------------------------------------
+// IsTemplateLiteralExpressionFinite
+// ------------------------------------------------------------------
 // prettier-ignore
-export function IsTemplateLiteralFinite(expression) {
-    return (IsBooleanExpression(expression) ? true :
-        IsNumberExpression(expression) || IsStringExpression(expression) ? false :
-            (expression.type === 'and') ? expression.expr.every((expr) => IsTemplateLiteralFinite(expr)) :
-                (expression.type === 'or') ? expression.expr.every((expr) => IsTemplateLiteralFinite(expr)) :
+export function IsTemplateLiteralExpressionFinite(expression) {
+    return (IsNumberExpression(expression) || IsStringExpression(expression) ? false :
+        IsBooleanExpression(expression) ? true :
+            (expression.type === 'and') ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) :
+                (expression.type === 'or') ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) :
                     (expression.type === 'const') ? true :
                         (() => { throw new TemplateLiteralFiniteError(`Unknown expression type`); })());
 }
+/** Returns true if this TemplateLiteral resolves to a finite set of values */
+export function IsTemplateLiteralFinite(schema) {
+    const expression = TemplateLiteralParseExact(schema.pattern);
+    return IsTemplateLiteralExpressionFinite(expression);
+}

package/build/import/type/template-literal/generate.d.mts

@@ -1,15 +1,21 @@
+import { TIsTemplateLiteralFinite } from './finite.mjs';
+import type { Assert } from '../helpers/index.mjs';
+import type { TBoolean } from '../boolean/index.mjs';
 import type { TTemplateLiteral, TTemplateLiteralKind } from './index.mjs';
 import type { TLiteral, TLiteralValue } from '../literal/index.mjs';
-import type { Expression } from './parser.mjs';
+import type { Expression } from './parse.mjs';
 import type { TUnion } from '../union/index.mjs';
+export declare class TemplateLiteralGenerateError extends Error {
+}
 type StringReduceUnary<L extends string, R extends string[]> = R extends [infer A extends string, ...infer B extends string[]] ? [`${L}${A}`, ...StringReduceUnary<L, B>] : [];
 type StringReduceBinary<L extends string[], R extends string[]> = L extends [infer A extends string, ...infer B extends string[]] ? [...StringReduceUnary<A, R>, ...StringReduceBinary<B, R>] : [];
 type StringReduceMany<T extends string[][]> = T extends [infer L extends string[], infer R extends string[], ...infer Rest extends string[][]] ? StringReduceMany<[StringReduceBinary<L, R>, ...Rest]> : T;
-type StringReduce<T extends string[][], O = StringReduceMany<T>> = 0 extends keyof O ? O[0] : [];
-type TemplateLiteralReduceUnion<T extends TTemplateLiteralKind[]> = T extends [infer L extends TLiteral, ...infer R extends TLiteral[]] ? [L['const'], ...TemplateLiteralReduceUnion<R>] : [];
-type TemplateLiteralReduce<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? L extends TLiteral<infer S extends TLiteralValue> ? [[S], ...TemplateLiteralReduce<R>] : L extends TUnion<infer S extends TTemplateLiteralKind[]> ? [TemplateLiteralReduceUnion<S>, ...TemplateLiteralReduce<R>] : [] : [];
-export declare class TemplateLiteralGenerateError extends Error {
-}
-export type TemplateLiteralGenerate<T> = T extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? TemplateLiteralReduce<S> extends infer R extends string[][] ? StringReduce<R> : [] : [];
-export declare function TemplateLiteralGenerate(expression: Expression): IterableIterator<string>;
+type StringReduce<T extends string[][], O = StringReduceMany<T>> = 0 extends keyof O ? Assert<O[0], string[]> : [];
+type FromTemplateLiteralUnionKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TLiteral, ...infer R extends TLiteral[]] ? [L['const'], ...FromTemplateLiteralUnionKinds<R>] : [];
+type FromTemplateLiteralKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? (L extends TLiteral<infer S extends TLiteralValue> ? [[S], ...FromTemplateLiteralKinds<R>] : L extends TUnion<infer S extends TTemplateLiteralKind[]> ? [FromTemplateLiteralUnionKinds<S>, ...FromTemplateLiteralKinds<R>] : L extends TBoolean ? [['true', 'false'], ...FromTemplateLiteralKinds<R>] : [
+]) : [];
+export declare function TemplateLiteralExpressionGenerate(expression: Expression): IterableIterator<string>;
+export type TTemplateLiteralGenerate<T extends TTemplateLiteral, F = TIsTemplateLiteralFinite<T>> = F extends true ? (T extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? FromTemplateLiteralKinds<S> extends infer R extends string[][] ? StringReduce<R> : [] : []) : [];
+/** Generates a tuple of strings from the given TemplateLiteral. Returns an empty tuple if infinite. */
+export declare function TemplateLiteralGenerate<T extends TTemplateLiteral>(schema: T): TTemplateLiteralGenerate<T>;
 export {};

package/build/import/type/template-literal/generate.mjs

@@ -1,5 +1,12 @@
+import { IsTemplateLiteralExpressionFinite } from './finite.mjs';
+import { TemplateLiteralParseExact } from './parse.mjs';
 // ------------------------------------------------------------------
-// GenerateFromExpression
+// TemplateLiteralGenerateError
+// ------------------------------------------------------------------
+export class TemplateLiteralGenerateError extends Error {
+}
+// ------------------------------------------------------------------
+// TemplateLiteralExpressionGenerate
 // ------------------------------------------------------------------
 // prettier-ignore
 function* GenerateReduce(buffer) {
@@ -13,23 +20,18 @@ function* GenerateReduce(buffer) {
 }
 // prettier-ignore
 function* GenerateAnd(expression) {
-    return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralGenerate(expr)]));
+    return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]));
 }
 // prettier-ignore
 function* GenerateOr(expression) {
     for (const expr of expression.expr)
-        yield* TemplateLiteralGenerate(expr);
+        yield* TemplateLiteralExpressionGenerate(expr);
 }
 // prettier-ignore
 function* GenerateConst(expression) {
     return yield expression.const;
 }
-// ------------------------------------------------------------------
-// TemplateLiteralGenerateError
-// ------------------------------------------------------------------
-export class TemplateLiteralGenerateError extends Error {
-}
-export function* TemplateLiteralGenerate(expression) {
+export function* TemplateLiteralExpressionGenerate(expression) {
     return expression.type === 'and'
         ? yield* GenerateAnd(expression)
         : expression.type === 'or'
@@ -40,3 +42,11 @@ export function* TemplateLiteralGenerate(expression) {
                     throw new TemplateLiteralGenerateError('Unknown expression');
                 })();
 }
+/** Generates a tuple of strings from the given TemplateLiteral. Returns an empty tuple if infinite. */
+export function TemplateLiteralGenerate(schema) {
+    const expression = TemplateLiteralParseExact(schema.pattern);
+    // prettier-ignore
+    return (IsTemplateLiteralExpressionFinite(expression)
+        ? [...TemplateLiteralExpressionGenerate(expression)]
+        : []);
+}

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

@@ -1,7 +1,7 @@
 export * from './finite.mjs';
 export * from './generate.mjs';
 export * from './syntax.mjs';
-export * from './parser.mjs';
+export * from './parse.mjs';
 export * from './pattern.mjs';
 export * from './union.mjs';
 export * from './template-literal.mjs';

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

@@ -1,7 +1,7 @@
 export * from './finite.mjs';
 export * from './generate.mjs';
 export * from './syntax.mjs';
-export * from './parser.mjs';
+export * from './parse.mjs';
 export * from './pattern.mjs';
 export * from './union.mjs';
 export * from './template-literal.mjs';

package/build/import/type/template-literal/{parser.mjs → parse.mjs}

@@ -127,16 +127,21 @@ function And(pattern) {
         (expressions.length === 1) ? expressions[0] :
             { type: 'and', expr: expressions });
 }
+// ------------------------------------------------------------------
+// TemplateLiteralParse
+// ------------------------------------------------------------------
 /** Parses a pattern and returns an expression tree */
-// prettier-ignore
 export function TemplateLiteralParse(pattern) {
+    // prettier-ignore
     return (IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
         IsPrecedenceOr(pattern) ? Or(pattern) :
             IsPrecedenceAnd(pattern) ? And(pattern) :
                 { type: 'const', const: pattern });
 }
+// ------------------------------------------------------------------
+// TemplateLiteralParseExact
+// ------------------------------------------------------------------
 /** Parses a pattern and strips forward and trailing ^ and $ */
-// prettier-ignore
 export function TemplateLiteralParseExact(pattern) {
     return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
 }

package/build/import/type/template-literal/syntax.d.mts

@@ -14,7 +14,7 @@ type FromUnion<T extends string> = UnionEvaluated<FromUnionLiteral<T>>;
 type FromTerminal<T extends string> = T extends 'boolean' ? TBoolean : T extends 'bigint' ? TBigInt : T extends 'number' ? TNumber : T extends 'string' ? TString : FromUnion<T>;
 type FromString<T extends string> = T extends `{${infer L}}${infer R}` ? [FromTerminal<L>, ...FromString<R>] : T extends `${infer L}$${infer R}` ? [TLiteral<L>, ...FromString<R>] : T extends `${infer L}` ? [TLiteral<L>] : [
 ];
-export type TemplateLiteralSyntax<T extends string> = (TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>);
+export type TTemplateLiteralSyntax<T extends string> = (TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>);
 /** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
 export declare function TemplateLiteralSyntax(syntax: string): TTemplateLiteralKind[];
 export {};

package/build/import/type/template-literal/syntax.mjs

@@ -49,7 +49,6 @@ function* FromSyntax(syntax) {
     }
     yield Literal(syntax);
 }
-// prettier-ignore
 /** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
 export function TemplateLiteralSyntax(syntax) {
     return [...FromSyntax(syntax)];

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

@@ -9,7 +9,7 @@ import type { TString } from '../string/index.mjs';
 import type { TBoolean } from '../boolean/index.mjs';
 import type { TNever } from '../never/index.mjs';
 import type { Static } from '../static/index.mjs';
-import { TemplateLiteralSyntax } from './syntax.mjs';
+import { TTemplateLiteralSyntax } from './syntax.mjs';
 import { EmptyString } from '../helpers/index.mjs';
 import { Kind } from '../symbols/index.mjs';
 type TemplateLiteralStaticKind<T, Acc extends string> = T extends TUnion<infer U> ? {
@@ -24,7 +24,7 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
     pattern: string;
 }
 /** `[Json]` Creates a TemplateLiteral type from template dsl string */
-export declare function TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
+export declare function TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TTemplateLiteralSyntax<T>;
 /** `[Json]` Creates a TemplateLiteral type */
 export declare function TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
 export {};

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

@@ -1,5 +1,5 @@
-import { TemplateLiteralPattern } from './pattern.mjs';
 import { TemplateLiteralSyntax } from './syntax.mjs';
+import { TemplateLiteralPattern } from './pattern.mjs';
 import { IsString } from '../guard/value.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates a TemplateLiteral type */

package/build/import/type/template-literal/union.d.mts

@@ -3,5 +3,5 @@ import { type TUnion } from '../union/index.mjs';
 import { type TLiteral } from '../literal/index.mjs';
 import { type TString } from '../string/index.mjs';
 import { type TNever } from '../never/index.mjs';
-/** Resolves a template literal as a TUnion */
-export declare function TemplateLiteralToUnion(template: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]>;
+/** Returns a Union from the given TemplateLiteral */
+export declare function TemplateLiteralToUnion(schema: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]>;

package/build/import/type/template-literal/union.mjs

@@ -1,17 +1,12 @@
 import { Union } from '../union/index.mjs';
 import { Literal } from '../literal/index.mjs';
-import { String } from '../string/index.mjs';
 import { TemplateLiteralGenerate } from './generate.mjs';
-import { TemplateLiteralParseExact } from './parser.mjs';
-import { IsTemplateLiteralFinite } from './finite.mjs';
 // ------------------------------------------------------------------
 // TemplateLiteralToUnion
 // ------------------------------------------------------------------
-/** Resolves a template literal as a TUnion */
-export function TemplateLiteralToUnion(template) {
-    const expression = TemplateLiteralParseExact(template.pattern);
-    if (!IsTemplateLiteralFinite(expression))
-        return String();
-    const literals = [...TemplateLiteralGenerate(expression)].map((value) => Literal(value));
-    return Union(literals);
+/** Returns a Union from the given TemplateLiteral */
+export function TemplateLiteralToUnion(schema) {
+    const R = TemplateLiteralGenerate(schema);
+    const L = R.map((S) => Literal(S));
+    return Union(L);
 }