@sinclair/typebox 0.32.0-dev-1 → 0.32.0-dev-2

package/type/schema/anyschema.d.ts

@@ -1,32 +0,0 @@
-import type { TAny } from '../any/index';
-import type { TArray } from '../array/index';
-import type { TAsyncIterator } from '../async-iterator/index';
-import type { TBigInt } from '../bigint/index';
-import type { TBoolean } from '../boolean/index';
-import type { TConstructor } from '../constructor/index';
-import type { TDate } from '../date/index';
-import type { TEnum } from '../enum/index';
-import type { TFunction } from '../function/index';
-import type { TInteger } from '../integer/index';
-import type { TIntersect } from '../intersect/index';
-import type { TIterator } from '../iterator/index';
-import type { TLiteral } from '../literal/index';
-import type { TNot } from '../not/index';
-import type { TNull } from '../null/index';
-import type { TNumber } from '../number/index';
-import type { TObject } from '../object/index';
-import type { TPromise } from '../promise/index';
-import type { TRecord } from '../record/index';
-import type { TThis } from '../recursive/index';
-import type { TRef } from '../ref/index';
-import type { TString } from '../string/index';
-import type { TSymbol } from '../symbol/index';
-import type { TTemplateLiteral } from '../template-literal/index';
-import type { TTuple } from '../tuple/index';
-import type { TUint8Array } from '../uint8array/index';
-import type { TUndefined } from '../undefined/index';
-import type { TUnion } from '../union/index';
-import type { TUnknown } from '../unknown/index';
-import type { TVoid } from '../void/index';
-import type { TSchema } from './schema';
-export type TAnySchema = TSchema | TAny | TArray | TAsyncIterator | TBigInt | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TIntersect | TIterator | TLiteral | TNot | TNull | TNumber | TObject | TPromise | TRecord | TRef | TString | TSymbol | TTemplateLiteral | TThis | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;

package/type/schema/index.d.ts

@@ -1,2 +0,0 @@
-export * from './anyschema';
-export * from './schema';

package/type/schema/schema.d.ts

@@ -1,29 +0,0 @@
-import { Kind, Hint, ReadonlyKind, OptionalKind } from '../symbols/index';
-export interface SchemaOptions {
-    $schema?: string;
-    /** Id for this schema */
-    $id?: string;
-    /** Title of this schema */
-    title?: string;
-    /** Description of this schema */
-    description?: string;
-    /** Default value for this schema */
-    default?: any;
-    /** Example values matching this schema */
-    examples?: any;
-    /** Optional annotation for readOnly */
-    readOnly?: boolean;
-    /** Optional annotation for writeOnly */
-    writeOnly?: boolean;
-    [prop: string]: any;
-}
-export interface TKind {
-    [Kind]: string;
-}
-export interface TSchema extends SchemaOptions, TKind {
-    [ReadonlyKind]?: string;
-    [OptionalKind]?: string;
-    [Hint]?: string;
-    params: unknown[];
-    static: unknown;
-}

package/type/schema/schema.js

@@ -1,30 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/type
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("../symbols/index");

package/type/static/index.d.ts

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

package/type/static/static.d.ts

@@ -1,34 +0,0 @@
-import type { Evaluate } from '../helpers/index';
-import type { TOptional } from '../optional/index';
-import type { TReadonly } from '../readonly/index';
-import type { TArray } from '../array/index';
-import type { TAsyncIterator } from '../async-iterator/index';
-import type { TConstructor } from '../constructor/index';
-import type { TEnum } from '../enum/index';
-import type { TFunction } from '../function/index';
-import type { TIntersect } from '../intersect/index';
-import type { TIterator } from '../iterator/index';
-import type { TNot } from '../not/index';
-import type { TObject, TProperties } from '../object/index';
-import type { TPromise } from '../promise/index';
-import type { TRecursive } from '../recursive/index';
-import type { TRecord } from '../record/index';
-import type { TRef } from '../ref/index';
-import type { TTuple } from '../tuple/index';
-import type { TUnion } from '../union/index';
-import type { TUnsafe } from '../unsafe/index';
-import type { TSchema } from '../schema/index';
-import type { TTransform } from '../transform/index';
-export type DecodeProperties<T extends TProperties> = {
-    [K in keyof T]: DecodeType<T[K]>;
-};
-export type DecodeRest<T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [DecodeType<L>, ...DecodeRest<R>] : [];
-export type DecodeType<T extends TSchema> = (T extends TOptional<infer S extends TSchema> ? TOptional<DecodeType<S>> : T extends TReadonly<infer S extends TSchema> ? TReadonly<DecodeType<S>> : T extends TTransform<infer _, infer R> ? TUnsafe<R> : T extends TArray<infer S extends TSchema> ? TArray<DecodeType<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> : T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<DecodeRest<P>, DecodeType<R>> : T extends TEnum<infer S> ? TEnum<S> : T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<DecodeRest<P>, DecodeType<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<DecodeRest<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<DecodeType<S>> : T extends TNot<infer S extends TSchema> ? TNot<DecodeType<S>> : T extends TObject<infer S> ? TObject<Evaluate<DecodeProperties<S>>> : T extends TPromise<infer S extends TSchema> ? TPromise<DecodeType<S>> : T extends TRecord<infer K, infer S> ? TRecord<K, DecodeType<S>> : T extends TRecursive<infer S extends TSchema> ? TRecursive<DecodeType<S>> : T extends TRef<infer S extends TSchema> ? TRef<DecodeType<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<DecodeRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<DecodeRest<S>> : T);
-/** Creates an decoded static type from a TypeBox type */
-export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<DecodeType<T>, P>;
-/** Creates an encoded static type from a TypeBox type */
-export type StaticEncode<T extends TSchema, P extends unknown[] = []> = Static<T, P>;
-/** Creates a static type from a TypeBox type */
-export type Static<T extends TSchema, P extends unknown[] = []> = (T & {
-    params: P;
-})['static'];

package/type/strict/index.d.ts

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

package/type/strict/strict.d.ts

@@ -1,3 +0,0 @@
-import type { TSchema } from '../schema/index';
-/** `[Json]` Omits compositing symbols from this schema */
-export declare function Strict<T extends TSchema>(schema: T): T;

package/type/string/index.d.ts

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

package/type/string/string.d.ts

@@ -1,25 +0,0 @@
-import { TSchema, SchemaOptions } from '../schema/index';
-import { Kind } from '../symbols/index';
-export type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex' | ({} & string);
-export type StringContentEncodingOption = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
-export interface StringOptions extends SchemaOptions {
-    /** The maximum string length */
-    maxLength?: number;
-    /** The minimum string length */
-    minLength?: number;
-    /** A regular expression pattern this string should match */
-    pattern?: string;
-    /** A format this string should match */
-    format?: StringFormatOption;
-    /** The content encoding for this string */
-    contentEncoding?: StringContentEncodingOption;
-    /** The content media type for this string */
-    contentMediaType?: string;
-}
-export interface TString extends TSchema, StringOptions {
-    [Kind]: 'String';
-    static: string;
-    type: 'string';
-}
-/** `[Json]` Creates a String type */
-export declare function String(options?: StringOptions): TString;

package/type/string/string.js

@@ -1,36 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/type
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.String = void 0;
-const index_1 = require("../symbols/index");
-/** `[Json]` Creates a String type */
-function String(options = {}) {
-    return { ...options, [index_1.Kind]: 'String', type: 'string' };
-}
-exports.String = String;

package/type/symbol/index.d.ts

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

package/type/symbol/symbol.d.ts

@@ -1,10 +0,0 @@
-import { TSchema, SchemaOptions } from '../schema/index';
-import { Kind } from '../symbols/index';
-export type SymbolValue = string | number | undefined;
-export interface TSymbol extends TSchema, SchemaOptions {
-    [Kind]: 'Symbol';
-    static: symbol;
-    type: 'symbol';
-}
-/** `[JavaScript]` Creates a Symbol type */
-export declare function Symbol(options?: SchemaOptions): TSymbol;

package/type/symbol/symbol.js

@@ -1,36 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/type
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Symbol = void 0;
-const index_1 = require("../symbols/index");
-/** `[JavaScript]` Creates a Symbol type */
-function Symbol(options) {
-    return { ...options, [index_1.Kind]: 'Symbol', type: 'symbol' };
-}
-exports.Symbol = Symbol;

package/type/symbols/index.d.ts

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

package/type/template-literal/finite.d.ts

@@ -1,16 +0,0 @@
-import type { TTemplateLiteral, TTemplateLiteralKind } from '../template-literal/index';
-import type { TUnion } from '../union/index';
-import type { TString } from '../string/index';
-import type { TBoolean } from '../boolean/index';
-import type { TNumber } from '../number/index';
-import type { TInteger } from '../integer/index';
-import type { TBigInt } from '../bigint/index';
-import type { TLiteral } from '../literal/index';
-import type { Expression } from './parser';
-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;
-export {};

package/type/template-literal/generate.d.ts

@@ -1,15 +0,0 @@
-import type { TTemplateLiteral, TTemplateLiteralKind } from './index';
-import type { TLiteral, TLiteralValue } from '../literal/index';
-import type { Expression } from './parser';
-import type { TUnion } from '../union/index';
-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>;
-export {};

package/type/template-literal/index.d.ts

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

package/type/template-literal/pattern.d.ts

@@ -1,4 +0,0 @@
-import type { TTemplateLiteralKind } from '../template-literal/index';
-export declare class TemplateLiteralPatternError extends Error {
-}
-export declare function TemplateLiteralPattern(kinds: TTemplateLiteralKind[]): string;

package/type/template-literal/pattern.js

@@ -1,61 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/type
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemplateLiteralPattern = exports.TemplateLiteralPatternError = void 0;
-const index_1 = require("../patterns/index");
-const index_2 = require("../symbols/index");
-const type_1 = require("../guard/type");
-// ------------------------------------------------------------------
-// TemplateLiteralPatternError
-// ------------------------------------------------------------------
-class TemplateLiteralPatternError extends Error {
-}
-exports.TemplateLiteralPatternError = TemplateLiteralPatternError;
-// ------------------------------------------------------------------
-// TemplateLiteralPattern
-// ------------------------------------------------------------------
-function Escape(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-// prettier-ignore
-function Visit(schema, acc) {
-    return ((0, type_1.TTemplateLiteral)(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) :
-        (0, type_1.TUnion)(schema) ? `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})` :
-            (0, type_1.TNumber)(schema) ? `${acc}${index_1.PatternNumber}` :
-                (0, type_1.TInteger)(schema) ? `${acc}${index_1.PatternNumber}` :
-                    (0, type_1.TBigInt)(schema) ? `${acc}${index_1.PatternNumber}` :
-                        (0, type_1.TString)(schema) ? `${acc}${index_1.PatternString}` :
-                            (0, type_1.TLiteral)(schema) ? `${acc}${Escape(schema.const.toString())}` :
-                                (0, type_1.TBoolean)(schema) ? `${acc}${index_1.PatternBoolean}` :
-                                    (() => { throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[index_2.Kind]}'`); })());
-}
-function TemplateLiteralPattern(kinds) {
-    return `^${kinds.map((schema) => Visit(schema, '')).join('')}\$`;
-}
-exports.TemplateLiteralPattern = TemplateLiteralPattern;

package/type/template-literal/syntax.d.ts

@@ -1,20 +0,0 @@
-import type { Ensure, Assert, Trim } from '../helpers/index';
-import type { TTemplateLiteralKind, TTemplateLiteral } from '../template-literal/index';
-import { type TLiteral } from '../literal/index';
-import { type TBoolean } from '../boolean/index';
-import { type TBigInt } from '../bigint/index';
-import { type TNumber } from '../number/index';
-import { type TString } from '../string/index';
-import { UnionResolve } from '../union/index';
-declare function FromUnion(syntax: string): IterableIterator<TTemplateLiteralKind>;
-declare function FromTerminal(syntax: string): IterableIterator<TTemplateLiteralKind>;
-type FromUnionLiteral<T extends string> = T extends `${infer L}|${infer R}` ? [TLiteral<Trim<L>>, ...FromUnionLiteral<R>] : T extends `${infer L}` ? [TLiteral<Trim<L>>] : [
-];
-type FromUnion<T extends string> = UnionResolve<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> = Ensure<TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>>;
-/** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
-export declare function TemplateLiteralSyntax(syntax: string): TTemplateLiteralKind[];
-export {};

package/type/template-literal/syntax.js

@@ -1,87 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/type
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemplateLiteralSyntax = void 0;
-const index_1 = require("../literal/index");
-const index_2 = require("../boolean/index");
-const index_3 = require("../bigint/index");
-const index_4 = require("../number/index");
-const index_5 = require("../string/index");
-const index_6 = require("../union/index");
-const index_7 = require("../never/index");
-// ------------------------------------------------------------------
-// SyntaxParsers
-// ------------------------------------------------------------------
-// prettier-ignore
-function* FromUnion(syntax) {
-    const trim = syntax.trim().replace(/"|'/g, '');
-    return (trim === 'boolean' ? yield (0, index_2.Boolean)() :
-        trim === 'number' ? yield (0, index_4.Number)() :
-            trim === 'bigint' ? yield (0, index_3.BigInt)() :
-                trim === 'string' ? yield (0, index_5.String)() :
-                    yield (() => {
-                        const literals = trim.split('|').map((literal) => (0, index_1.Literal)(literal.trim()));
-                        return (literals.length === 0 ? (0, index_7.Never)() :
-                            literals.length === 1 ? literals[0] :
-                                (0, index_6.Union)(literals));
-                    })());
-}
-// prettier-ignore
-function* FromTerminal(syntax) {
-    if (syntax[1] !== '{') {
-        const L = (0, index_1.Literal)('$');
-        const R = FromSyntax(syntax.slice(1));
-        return yield* [L, ...R];
-    }
-    for (let i = 2; i < syntax.length; i++) {
-        if (syntax[i] === '}') {
-            const L = FromUnion(syntax.slice(2, i));
-            const R = FromSyntax(syntax.slice(i + 1));
-            return yield* [...L, ...R];
-        }
-    }
-    yield (0, index_1.Literal)(syntax);
-}
-// prettier-ignore
-function* FromSyntax(syntax) {
-    for (let i = 0; i < syntax.length; i++) {
-        if (syntax[i] === '$') {
-            const L = (0, index_1.Literal)(syntax.slice(0, i));
-            const R = FromTerminal(syntax.slice(i));
-            return yield* [L, ...R];
-        }
-    }
-    yield (0, index_1.Literal)(syntax);
-}
-// prettier-ignore
-/** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
-function TemplateLiteralSyntax(syntax) {
-    return [...FromSyntax(syntax)];
-}
-exports.TemplateLiteralSyntax = TemplateLiteralSyntax;

package/type/template-literal/template-literal.d.ts

@@ -1,30 +0,0 @@
-import type { TSchema, SchemaOptions } from '../schema/index';
-import type { Assert } from '../helpers/index';
-import type { TUnion } from '../union/index';
-import type { TLiteral } from '../literal/index';
-import type { TInteger } from '../integer/index';
-import type { TNumber } from '../number/index';
-import type { TBigInt } from '../bigint/index';
-import type { TString } from '../string/index';
-import type { TBoolean } from '../boolean/index';
-import type { TNever } from '../never/index';
-import type { Static } from '../static/index';
-import { TemplateLiteralSyntax } from './syntax';
-import { EmptyString } from '../helpers/index';
-import { Kind } from '../symbols/index';
-type TemplateLiteralResolveConst<T, Acc extends string> = T extends TUnion<infer U> ? {
-    [K in keyof U]: TemplateLiteralResolve<Assert<[U[K]], TTemplateLiteralKind[]>, Acc>;
-}[number] : T extends TTemplateLiteral ? `${Static<T>}` : T extends TLiteral<infer U> ? `${U}` : T extends TString ? `${string}` : T extends TNumber ? `${number}` : T extends TBigInt ? `${bigint}` : T extends TBoolean ? `${boolean}` : never;
-export type TemplateLiteralResolve<T extends TTemplateLiteralKind[], Acc extends string> = T extends [infer L, ...infer R] ? `${TemplateLiteralResolveConst<L, Acc>}${TemplateLiteralResolve<Assert<R, TTemplateLiteralKind[]>, Acc>}` : Acc;
-export type TTemplateLiteralKind = TTemplateLiteral | TUnion | TLiteral | TInteger | TNumber | TBigInt | TString | TBoolean | TNever;
-export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
-    [Kind]: 'TemplateLiteral';
-    static: TemplateLiteralResolve<T, EmptyString>;
-    type: 'string';
-    pattern: string;
-}
-/** `[Json]` Creates a TemplateLiteral type from template dsl string */
-export declare function TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
-/** `[Json]` Creates a TemplateLiteral type */
-export declare function TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
-export {};

package/type/template-literal/template-literal.js

@@ -1,43 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/type
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemplateLiteral = void 0;
-const pattern_1 = require("./pattern");
-const syntax_1 = require("./syntax");
-const value_1 = require("../guard/value");
-const index_1 = require("../symbols/index");
-/** `[Json]` Creates a TemplateLiteral type */
-// prettier-ignore
-function TemplateLiteral(unresolved, options = {}) {
-    const pattern = (0, value_1.IsString)(unresolved)
-        ? (0, pattern_1.TemplateLiteralPattern)((0, syntax_1.TemplateLiteralSyntax)(unresolved))
-        : (0, pattern_1.TemplateLiteralPattern)(unresolved);
-    return { ...options, [index_1.Kind]: 'TemplateLiteral', type: 'string', pattern };
-}
-exports.TemplateLiteral = TemplateLiteral;

package/type/template-literal/union.d.ts

@@ -1,7 +0,0 @@
-import type { TTemplateLiteral } from './template-literal';
-import { type TUnion } from '../union/index';
-import { type TLiteral } from '../literal/index';
-import { type TString } from '../string/index';
-import { type TNever } from '../never/index';
-/** Resolves a template literal as a TUnion */
-export declare function TemplateLiteralToUnion(template: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]>;

package/type/template-literal/union.js

@@ -1,48 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/type
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemplateLiteralToUnion = void 0;
-const index_1 = require("../union/index");
-const index_2 = require("../literal/index");
-const index_3 = require("../string/index");
-const generate_1 = require("./generate");
-const parser_1 = require("./parser");
-const finite_1 = require("./finite");
-// ------------------------------------------------------------------
-// TemplateLiteralToUnion
-// ------------------------------------------------------------------
-/** Resolves a template literal as a TUnion */
-function TemplateLiteralToUnion(template) {
-    const expression = (0, parser_1.TemplateLiteralParseExact)(template.pattern);
-    if (!(0, finite_1.IsTemplateLiteralFinite)(expression))
-        return (0, index_3.String)();
-    const literals = [...(0, generate_1.TemplateLiteralGenerate)(expression)].map((value) => (0, index_2.Literal)(value));
-    return (0, index_1.Union)(literals);
-}
-exports.TemplateLiteralToUnion = TemplateLiteralToUnion;

package/type/transform/index.d.ts

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