@sinclair/typebox 0.31.27 → 0.32.0-dev-1

package/type/template-literal/parser.js

@@ -0,0 +1,175 @@
+"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.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.TemplateLiteralParserError = void 0;
+// ------------------------------------------------------------------
+// TemplateLiteralParserError
+// ------------------------------------------------------------------
+class TemplateLiteralParserError extends Error {
+}
+exports.TemplateLiteralParserError = TemplateLiteralParserError;
+// prettier-ignore
+function IsNonEscaped(pattern, index, char) {
+    return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
+}
+// prettier-ignore
+function IsOpenParen(pattern, index) {
+    return IsNonEscaped(pattern, index, '(');
+}
+// prettier-ignore
+function IsCloseParen(pattern, index) {
+    return IsNonEscaped(pattern, index, ')');
+}
+// prettier-ignore
+function IsSeparator(pattern, index) {
+    return IsNonEscaped(pattern, index, '|');
+}
+// prettier-ignore
+function IsGroup(pattern) {
+    if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
+        return false;
+    let count = 0;
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index))
+            count += 1;
+        if (IsCloseParen(pattern, index))
+            count -= 1;
+        if (count === 0 && index !== pattern.length - 1)
+            return false;
+    }
+    return true;
+}
+// prettier-ignore
+function InGroup(pattern) {
+    return pattern.slice(1, pattern.length - 1);
+}
+// prettier-ignore
+function IsPrecedenceOr(pattern) {
+    let count = 0;
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index))
+            count += 1;
+        if (IsCloseParen(pattern, index))
+            count -= 1;
+        if (IsSeparator(pattern, index) && count === 0)
+            return true;
+    }
+    return false;
+}
+// prettier-ignore
+function IsPrecedenceAnd(pattern) {
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index))
+            return true;
+    }
+    return false;
+}
+// prettier-ignore
+function Or(pattern) {
+    let [count, start] = [0, 0];
+    const expressions = [];
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index))
+            count += 1;
+        if (IsCloseParen(pattern, index))
+            count -= 1;
+        if (IsSeparator(pattern, index) && count === 0) {
+            const range = pattern.slice(start, index);
+            if (range.length > 0)
+                expressions.push(TemplateLiteralParse(range));
+            start = index + 1;
+        }
+    }
+    const range = pattern.slice(start);
+    if (range.length > 0)
+        expressions.push(TemplateLiteralParse(range));
+    if (expressions.length === 0)
+        return { type: 'const', const: '' };
+    if (expressions.length === 1)
+        return expressions[0];
+    return { type: 'or', expr: expressions };
+}
+// prettier-ignore
+function And(pattern) {
+    function Group(value, index) {
+        if (!IsOpenParen(value, index))
+            throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
+        let count = 0;
+        for (let scan = index; scan < value.length; scan++) {
+            if (IsOpenParen(value, scan))
+                count += 1;
+            if (IsCloseParen(value, scan))
+                count -= 1;
+            if (count === 0)
+                return [index, scan];
+        }
+        throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
+    }
+    function Range(pattern, index) {
+        for (let scan = index; scan < pattern.length; scan++) {
+            if (IsOpenParen(pattern, scan))
+                return [index, scan];
+        }
+        return [index, pattern.length];
+    }
+    const expressions = [];
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index)) {
+            const [start, end] = Group(pattern, index);
+            const range = pattern.slice(start, end + 1);
+            expressions.push(TemplateLiteralParse(range));
+            index = end;
+        }
+        else {
+            const [start, end] = Range(pattern, index);
+            const range = pattern.slice(start, end);
+            if (range.length > 0)
+                expressions.push(TemplateLiteralParse(range));
+            index = end - 1;
+        }
+    }
+    return ((expressions.length === 0) ? { type: 'const', const: '' } :
+        (expressions.length === 1) ? expressions[0] :
+            { type: 'and', expr: expressions });
+}
+/** Parses a pattern and returns an expression tree */
+// prettier-ignore
+function TemplateLiteralParse(pattern) {
+    return (IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
+        IsPrecedenceOr(pattern) ? Or(pattern) :
+            IsPrecedenceAnd(pattern) ? And(pattern) :
+                { type: 'const', const: pattern });
+}
+exports.TemplateLiteralParse = TemplateLiteralParse;
+/** Parses a pattern and strips forward and trailing ^ and $ */
+// prettier-ignore
+function TemplateLiteralParseExact(pattern) {
+    return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
+}
+exports.TemplateLiteralParseExact = TemplateLiteralParseExact;

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,61 @@
+"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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,87 @@
+"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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,43 @@
+"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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,48 @@
+"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

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

package/type/transform/index.js

@@ -0,0 +1,44 @@
+"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.
+
+---------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./transform"), exports);

package/type/transform/transform.d.ts

@@ -0,0 +1,29 @@
+import type { TSchema } from '../schema/index';
+import type { Static, StaticDecode } from '../static';
+import { TransformKind } from '../symbols/index';
+export declare class TransformDecodeBuilder<T extends TSchema> {
+    private readonly schema;
+    constructor(schema: T);
+    Decode<U extends unknown, D extends TransformFunction<StaticDecode<T>, U>>(decode: D): TransformEncodeBuilder<T, D>;
+}
+export declare class TransformEncodeBuilder<T extends TSchema, D extends TransformFunction> {
+    private readonly schema;
+    private readonly decode;
+    constructor(schema: T, decode: D);
+    private EncodeTransform;
+    private EncodeSchema;
+    Encode<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E): TTransform<T, ReturnType<D>>;
+}
+export type TransformFunction<T = any, U = any> = (value: T) => U;
+export interface TransformOptions<I extends TSchema = TSchema, O extends unknown = unknown> {
+    Decode: TransformFunction<StaticDecode<I>, O>;
+    Encode: TransformFunction<O, StaticDecode<I>>;
+}
+export type TTransformResolve<T extends TSchema, P extends unknown[] = []> = T extends TTransform<infer _, infer S> ? S : Static<T, P>;
+export interface TTransform<I extends TSchema = TSchema, O extends unknown = unknown> extends TSchema {
+    static: TTransformResolve<I, this['params']>;
+    [TransformKind]: TransformOptions<I, O>;
+    [key: string]: any;
+}
+/** `[Json]` Creates a Transform type */
+export declare function Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I>;

package/type/transform/transform.js

@@ -0,0 +1,72 @@
+"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.Transform = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = void 0;
+const type_1 = require("../guard/type");
+const type_2 = require("../clone/type");
+const index_1 = require("../symbols/index");
+// ------------------------------------------------------------------
+// TransformBuilders
+// ------------------------------------------------------------------
+class TransformDecodeBuilder {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    Decode(decode) {
+        return new TransformEncodeBuilder(this.schema, decode);
+    }
+}
+exports.TransformDecodeBuilder = TransformDecodeBuilder;
+// prettier-ignore
+class TransformEncodeBuilder {
+    constructor(schema, decode) {
+        this.schema = schema;
+        this.decode = decode;
+    }
+    EncodeTransform(encode, schema) {
+        const Encode = (value) => schema[index_1.TransformKind].Encode(encode(value));
+        const Decode = (value) => this.decode(schema[index_1.TransformKind].Decode(value));
+        const Codec = { Encode: Encode, Decode: Decode };
+        return { ...schema, [index_1.TransformKind]: Codec };
+    }
+    EncodeSchema(encode, schema) {
+        const Codec = { Decode: this.decode, Encode: encode };
+        return { ...schema, [index_1.TransformKind]: Codec };
+    }
+    Encode(encode) {
+        const schema = (0, type_2.CloneType)(this.schema);
+        return ((0, type_1.TTransform)(schema) ? this.EncodeTransform(encode, schema) : this.EncodeSchema(encode, schema));
+    }
+}
+exports.TransformEncodeBuilder = TransformEncodeBuilder;
+/** `[Json]` Creates a Transform type */
+function Transform(schema) {
+    return new TransformDecodeBuilder(schema);
+}
+exports.Transform = Transform;

package/type/tuple/index.d.ts

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