@sinclair/typebox 0.32.0-dev-4 → 0.32.0-dev-5

package/build/import/type/ref/ref.mjs

@@ -0,0 +1,13 @@
+import { Kind } from '../symbols/index.mjs';
+import { IsString, IsUndefined } from '../guard/value.mjs';
+export function Ref(unresolved, options = {}) {
+    if (IsString(unresolved))
+        return { ...options, [Kind]: 'Ref', $ref: unresolved };
+    if (IsUndefined(unresolved.$id))
+        throw new Error('Reference target type must specify an $id');
+    return {
+        ...options,
+        [Kind]: 'Ref',
+        $ref: unresolved.$id,
+    };
+}

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

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

package/build/import/type/regexp/regexp.mjs

@@ -0,0 +1,6 @@
+import { IsString } from '../guard/value.mjs';
+import { Kind } from '../symbols/index.mjs';
+export function RegExp(unresolved, options = {}) {
+    const pattern = IsString(unresolved) ? unresolved : unresolved.source;
+    return { ...options, [Kind]: 'String', type: 'string', pattern };
+}

package/build/import/type/registry/format.mjs

@@ -0,0 +1,19 @@
+const map = new Map();
+export function Entries() {
+    return new Map(map);
+}
+export function Clear() {
+    return map.clear();
+}
+export function Delete(format) {
+    return map.delete(format);
+}
+export function Has(format) {
+    return map.has(format);
+}
+export function Set(format, func) {
+    map.set(format, func);
+}
+export function Get(format) {
+    return map.get(format);
+}

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

@@ -0,0 +1,2 @@
+export * as FormatRegistry from './format.mjs';
+export * as TypeRegistry from './type.mjs';

package/build/import/type/registry/type.mjs

@@ -0,0 +1,19 @@
+const map = new Map();
+export function Entries() {
+    return new Map(map);
+}
+export function Clear() {
+    return map.clear();
+}
+export function Delete(kind) {
+    return map.delete(kind);
+}
+export function Has(kind) {
+    return map.has(kind);
+}
+export function Set(kind, func) {
+    map.set(kind, func);
+}
+export function Get(kind) {
+    return map.get(kind);
+}

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

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

package/build/import/type/required/required.mjs

@@ -0,0 +1,35 @@
+import { Intersect } from '../intersect/index.mjs';
+import { Union } from '../union/index.mjs';
+import { Object } from '../object/index.mjs';
+import { OptionalKind, TransformKind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+import { Discard } from '../discard/index.mjs';
+import { TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType } from '../guard/type.mjs';
+function FromIntersect(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [RequiredResolve(L), ...FromIntersect(R)]
+        : []);
+}
+function FromUnion(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [RequiredResolve(L), ...FromUnion(R)]
+        : []);
+}
+function FromProperties(T) {
+    return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K) => {
+        return { ...Acc, [K]: Discard(T[K], [OptionalKind]) };
+    }, {});
+}
+export function RequiredResolve(T) {
+    return (IsIntersectType(T) ? Intersect(FromIntersect(T.allOf)) :
+        IsUnionType(T) ? Union(FromUnion(T.anyOf)) :
+            IsObjectType(T) ? Object(FromProperties(T.properties)) :
+                Object({}));
+}
+export function Required(T, options = {}) {
+    const D = Discard(T, [TransformKind, '$id', 'required']);
+    const R = CloneType(RequiredResolve(T), options);
+    return { ...D, ...R };
+}

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

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

package/build/import/type/rest/rest.mjs

@@ -0,0 +1,8 @@
+import { CloneRest } from '../clone/type.mjs';
+import { TIntersect as IsIntersectType, TUnion as IsUnionType, TTuple as IsTupleType } from '../guard/type.mjs';
+export function RestResolve(T) {
+    return (IsIntersectType(T) ? [...T.allOf] : IsUnionType(T) ? [...T.anyOf] : IsTupleType(T) ? [...(T.items ?? [])] : []);
+}
+export function Rest(T) {
+    return CloneRest(RestResolve(T));
+}

package/build/import/type/return-type/index.mjs

@@ -0,0 +1 @@
+export * from './return-type.mjs';

package/build/import/type/return-type/return-type.mjs

@@ -0,0 +1,4 @@
+import { CloneType } from '../clone/type.mjs';
+export function ReturnType(schema, options = {}) {
+    return CloneType(schema.returns, options);
+}

package/build/import/type/schema/anyschema.mjs

@@ -0,0 +1 @@
+export {};

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

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

package/build/import/type/schema/schema.mjs

@@ -0,0 +1 @@
+import { Kind, Hint, ReadonlyKind, OptionalKind } from '../symbols/index.mjs';

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

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

package/build/import/type/static/static.mjs

@@ -0,0 +1 @@
+export {};

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

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

package/build/import/type/strict/strict.mjs

@@ -0,0 +1,3 @@
+export function Strict(schema) {
+    return JSON.parse(JSON.stringify(schema));
+}

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

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

package/build/import/type/string/string.mjs

@@ -0,0 +1,4 @@
+import { Kind } from '../symbols/index.mjs';
+export function String(options = {}) {
+    return { ...options, [Kind]: 'String', type: 'string' };
+}

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

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

package/build/import/type/symbol/symbol.mjs

@@ -0,0 +1,4 @@
+import { Kind } from '../symbols/index.mjs';
+export function Symbol(options) {
+    return { ...options, [Kind]: 'Symbol', type: 'symbol' };
+}

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

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

package/build/import/type/symbols/symbols.mjs

@@ -0,0 +1,5 @@
+export const TransformKind = Symbol.for('TypeBox.Transform');
+export const ReadonlyKind = Symbol.for('TypeBox.Readonly');
+export const OptionalKind = Symbol.for('TypeBox.Optional');
+export const Hint = Symbol.for('TypeBox.Hint');
+export const Kind = Symbol.for('TypeBox.Kind');

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

@@ -0,0 +1,29 @@
+export class TemplateLiteralFiniteError extends Error {
+}
+function IsNumberExpression(expression) {
+    return (expression.type === 'or' &&
+        expression.expr.length === 2 &&
+        expression.expr[0].type === 'const' &&
+        expression.expr[0].const === '0' &&
+        expression.expr[1].type === 'const' &&
+        expression.expr[1].const === '[1-9][0-9]*');
+}
+function IsBooleanExpression(expression) {
+    return (expression.type === 'or' &&
+        expression.expr.length === 2 &&
+        expression.expr[0].type === 'const' &&
+        expression.expr[0].const === 'true' &&
+        expression.expr[1].type === 'const' &&
+        expression.expr[1].const === 'false');
+}
+function IsStringExpression(expression) {
+    return expression.type === 'const' && expression.const === '.*';
+}
+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)) :
+                    (expression.type === 'const') ? true :
+                        (() => { throw new TemplateLiteralFiniteError(`Unknown expression type`); })());
+}

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

@@ -0,0 +1,32 @@
+function* GenerateReduce(buffer) {
+    if (buffer.length === 1)
+        return yield* buffer[0];
+    for (const left of buffer[0]) {
+        for (const right of GenerateReduce(buffer.slice(1))) {
+            yield `${left}${right}`;
+        }
+    }
+}
+function* GenerateAnd(expression) {
+    return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralGenerate(expr)]));
+}
+function* GenerateOr(expression) {
+    for (const expr of expression.expr)
+        yield* TemplateLiteralGenerate(expr);
+}
+function* GenerateConst(expression) {
+    return yield expression.const;
+}
+export class TemplateLiteralGenerateError extends Error {
+}
+export function* TemplateLiteralGenerate(expression) {
+    return expression.type === 'and'
+        ? yield* GenerateAnd(expression)
+        : expression.type === 'or'
+            ? yield* GenerateOr(expression)
+            : expression.type === 'const'
+                ? yield* GenerateConst(expression)
+                : (() => {
+                    throw new TemplateLiteralGenerateError('Unknown expression');
+                })();
+}

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

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

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

@@ -0,0 +1,125 @@
+export class TemplateLiteralParserError extends Error {
+}
+function IsNonEscaped(pattern, index, char) {
+    return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
+}
+function IsOpenParen(pattern, index) {
+    return IsNonEscaped(pattern, index, '(');
+}
+function IsCloseParen(pattern, index) {
+    return IsNonEscaped(pattern, index, ')');
+}
+function IsSeparator(pattern, index) {
+    return IsNonEscaped(pattern, index, '|');
+}
+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;
+}
+function InGroup(pattern) {
+    return pattern.slice(1, pattern.length - 1);
+}
+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;
+}
+function IsPrecedenceAnd(pattern) {
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index))
+            return true;
+    }
+    return false;
+}
+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 };
+}
+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 });
+}
+export function TemplateLiteralParse(pattern) {
+    return (IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
+        IsPrecedenceOr(pattern) ? Or(pattern) :
+            IsPrecedenceAnd(pattern) ? And(pattern) :
+                { type: 'const', const: pattern });
+}
+export function TemplateLiteralParseExact(pattern) {
+    return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
+}

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

@@ -0,0 +1,22 @@
+import { PatternNumber, PatternString, PatternBoolean } from '../patterns/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+import { TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, TNumber as IsNumberType, TInteger as IsIntegerType, TBigInt as IsBigIntType, TString as IsStringType, TLiteral as IsLiteralType, TBoolean as IsBooleanType, } from '../guard/type.mjs';
+export class TemplateLiteralPatternError extends Error {
+}
+function Escape(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function Visit(schema, acc) {
+    return (IsTemplateLiteralType(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) :
+        IsUnionType(schema) ? `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})` :
+            IsNumberType(schema) ? `${acc}${PatternNumber}` :
+                IsIntegerType(schema) ? `${acc}${PatternNumber}` :
+                    IsBigIntType(schema) ? `${acc}${PatternNumber}` :
+                        IsStringType(schema) ? `${acc}${PatternString}` :
+                            IsLiteralType(schema) ? `${acc}${Escape(schema.const.toString())}` :
+                                IsBooleanType(schema) ? `${acc}${PatternBoolean}` :
+                                    (() => { throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`); })());
+}
+export function TemplateLiteralPattern(kinds) {
+    return `^${kinds.map((schema) => Visit(schema, '')).join('')}\$`;
+}

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

@@ -0,0 +1,48 @@
+import { Literal } from '../literal/index.mjs';
+import { Boolean } from '../boolean/index.mjs';
+import { BigInt } from '../bigint/index.mjs';
+import { Number } from '../number/index.mjs';
+import { String } from '../string/index.mjs';
+import { Union } from '../union/index.mjs';
+import { Never } from '../never/index.mjs';
+function* FromUnion(syntax) {
+    const trim = syntax.trim().replace(/"|'/g, '');
+    return (trim === 'boolean' ? yield Boolean() :
+        trim === 'number' ? yield Number() :
+            trim === 'bigint' ? yield BigInt() :
+                trim === 'string' ? yield String() :
+                    yield (() => {
+                        const literals = trim.split('|').map((literal) => Literal(literal.trim()));
+                        return (literals.length === 0 ? Never() :
+                            literals.length === 1 ? literals[0] :
+                                Union(literals));
+                    })());
+}
+function* FromTerminal(syntax) {
+    if (syntax[1] !== '{') {
+        const L = 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 Literal(syntax);
+}
+function* FromSyntax(syntax) {
+    for (let i = 0; i < syntax.length; i++) {
+        if (syntax[i] === '$') {
+            const L = Literal(syntax.slice(0, i));
+            const R = FromTerminal(syntax.slice(i));
+            return yield* [L, ...R];
+        }
+    }
+    yield Literal(syntax);
+}
+export function TemplateLiteralSyntax(syntax) {
+    return [...FromSyntax(syntax)];
+}

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

@@ -0,0 +1,10 @@
+import { TemplateLiteralPattern } from './pattern.mjs';
+import { TemplateLiteralSyntax } from './syntax.mjs';
+import { IsString } from '../guard/value.mjs';
+import { Kind } from '../symbols/index.mjs';
+export function TemplateLiteral(unresolved, options = {}) {
+    const pattern = IsString(unresolved)
+        ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved))
+        : TemplateLiteralPattern(unresolved);
+    return { ...options, [Kind]: 'TemplateLiteral', type: 'string', pattern };
+}

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

@@ -0,0 +1,13 @@
+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';
+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);
+}

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

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

package/build/import/type/transform/transform.mjs

@@ -0,0 +1,37 @@
+import { TTransform as IsTransform } from '../guard/type.mjs';
+import { CloneType } from '../clone/type.mjs';
+import { TransformKind } from '../symbols/index.mjs';
+export class TransformDecodeBuilder {
+    schema;
+    constructor(schema) {
+        this.schema = schema;
+    }
+    Decode(decode) {
+        return new TransformEncodeBuilder(this.schema, decode);
+    }
+}
+export class TransformEncodeBuilder {
+    schema;
+    decode;
+    constructor(schema, decode) {
+        this.schema = schema;
+        this.decode = decode;
+    }
+    EncodeTransform(encode, schema) {
+        const Encode = (value) => schema[TransformKind].Encode(encode(value));
+        const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
+        const Codec = { Encode: Encode, Decode: Decode };
+        return { ...schema, [TransformKind]: Codec };
+    }
+    EncodeSchema(encode, schema) {
+        const Codec = { Decode: this.decode, Encode: encode };
+        return { ...schema, [TransformKind]: Codec };
+    }
+    Encode(encode) {
+        const schema = CloneType(this.schema);
+        return (IsTransform(schema) ? this.EncodeTransform(encode, schema) : this.EncodeSchema(encode, schema));
+    }
+}
+export function Transform(schema) {
+    return new TransformDecodeBuilder(schema);
+}

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

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

package/build/import/type/tuple/tuple.mjs

@@ -0,0 +1,8 @@
+import { CloneRest } from '../clone/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+export function Tuple(items, options = {}) {
+    const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
+    return (items.length > 0 ?
+        { ...options, [Kind]: 'Tuple', type: 'array', items: CloneRest(items), additionalItems, minItems, maxItems } :
+        { ...options, [Kind]: 'Tuple', type: 'array', minItems, maxItems });
+}

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

@@ -0,0 +1,6 @@
+export { JsonTypeBuilder } from './json.mjs';
+import * as TypeBuilder from './type.mjs';
+import { JavaScriptTypeBuilder } from './javascript.mjs';
+const Type = TypeBuilder;
+export { JavaScriptTypeBuilder };
+export { Type };

package/build/import/type/type/javascript.mjs

@@ -0,0 +1,71 @@
+import { JsonTypeBuilder } from './json.mjs';
+import { AsyncIterator } from '../async-iterator/index.mjs';
+import { Awaited } from '../awaited/index.mjs';
+import { BigInt } from '../bigint/index.mjs';
+import { Constructor } from '../constructor/index.mjs';
+import { ConstructorParameters } from '../constructor-parameters/index.mjs';
+import { Date } from '../date/index.mjs';
+import { Function } from '../function/index.mjs';
+import { InstanceType } from '../instance-type/index.mjs';
+import { Iterator } from '../iterator/index.mjs';
+import { Parameters } from '../parameters/index.mjs';
+import { Promise } from '../promise/index.mjs';
+import { RegExp } from '../regexp/index.mjs';
+import { ReturnType } from '../return-type/index.mjs';
+import { Symbol } from '../symbol/index.mjs';
+import { Uint8Array } from '../uint8array/index.mjs';
+import { Undefined } from '../undefined/index.mjs';
+import { Void } from '../void/index.mjs';
+export class JavaScriptTypeBuilder extends JsonTypeBuilder {
+    AsyncIterator(items, options = {}) {
+        return AsyncIterator(items, options);
+    }
+    Awaited(schema, options = {}) {
+        return Awaited(schema, options);
+    }
+    BigInt(options = {}) {
+        return BigInt(options);
+    }
+    ConstructorParameters(schema, options = {}) {
+        return ConstructorParameters(schema, options);
+    }
+    Constructor(parameters, returns, options) {
+        return Constructor(parameters, returns, options);
+    }
+    Date(options = {}) {
+        return Date(options);
+    }
+    Function(parameters, returns, options) {
+        return Function(parameters, returns, options);
+    }
+    InstanceType(schema, options = {}) {
+        return InstanceType(schema, options);
+    }
+    Iterator(items, options = {}) {
+        return Iterator(items, options);
+    }
+    Parameters(schema, options = {}) {
+        return Parameters(schema, options);
+    }
+    Promise(item, options = {}) {
+        return Promise(item, options);
+    }
+    RegExp(unresolved, options = {}) {
+        return RegExp(unresolved, options);
+    }
+    ReturnType(schema, options = {}) {
+        return ReturnType(schema, options);
+    }
+    Symbol(options) {
+        return Symbol(options);
+    }
+    Undefined(options = {}) {
+        return Undefined(options);
+    }
+    Uint8Array(options = {}) {
+        return Uint8Array(options);
+    }
+    Void(options = {}) {
+        return Void(options);
+    }
+}