@sinclair/typebox 0.33.18 → 0.33.20

package/build/cjs/index.d.ts

@@ -7,6 +7,7 @@ export * from './type/patterns/index';
 export * from './type/registry/index';
 export * from './type/sets/index';
 export * from './type/symbols/index';
+export * from './parse/index';
 export * from './type/any/index';
 export * from './type/array/index';
 export * from './type/async-iterator/index';

package/build/cjs/index.js

@@ -28,6 +28,10 @@ __exportStar(require("./type/registry/index"), exports);
 __exportStar(require("./type/sets/index"), exports);
 __exportStar(require("./type/symbols/index"), exports);
 // ------------------------------------------------------------------
+// Parse
+// ------------------------------------------------------------------
+__exportStar(require("./parse/index"), exports);
+// ------------------------------------------------------------------
 // Types
 // ------------------------------------------------------------------
 __exportStar(require("./type/any/index"), exports);
@@ -91,6 +95,6 @@ __exportStar(require("./type/unknown/index"), exports);
 __exportStar(require("./type/unsafe/index"), exports);
 __exportStar(require("./type/void/index"), exports);
 // ------------------------------------------------------------------
-// Namespace
+// Type.*
 // ------------------------------------------------------------------
 __exportStar(require("./type/type/index"), exports);

package/build/cjs/parse/index.d.ts

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

package/build/cjs/parse/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+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("./parse"), exports);

package/build/cjs/parse/parse.d.ts

@@ -0,0 +1,11 @@
+import { Static } from './parsebox/index';
+import { TSchema, SchemaOptions } from '../type/schema/index';
+import { Type } from './static';
+/** `[Experimental]` Parses a TypeScript type annotation as an inferred TypeBox type */
+export declare function Parse<Code extends string, Context extends Record<PropertyKey, TSchema> = {}>(context: Context, code: Code, options?: SchemaOptions): Static.Parse<Type, Code, Context>[0];
+/** `[Experimental]` Parses a TypeScript type annotation as an inferred TypeBox type */
+export declare function Parse<Code extends string>(code: Code, options?: SchemaOptions): Static.Parse<Type, Code, {}>[0];
+/** `[Experimental]` Parses a TypeScript type annotation as TSchema */
+export declare function ParseOnly<Code extends string, Context extends Record<PropertyKey, TSchema> = {}>(context: Context, code: Code, options?: SchemaOptions): TSchema | undefined;
+/** `[Experimental]` Parses a TypeScript type annotation as TSchema */
+export declare function ParseOnly<Code extends string>(code: Code, options?: SchemaOptions): TSchema | undefined;

package/build/cjs/parse/parse.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parse = Parse;
+exports.ParseOnly = ParseOnly;
+const type_1 = require("../type/create/type");
+const runtime_1 = require("./runtime");
+/** `[Experimental]` Parses a TypeScript type annotation as an inferred TypeBox type */
+function Parse(...args) {
+    return ParseOnly.apply(null, args);
+}
+/** `[Experimental]` Parses a TypeScript type annotation as TSchema */
+function ParseOnly(...args) {
+    const withContext = typeof args[0] === 'string' ? false : true;
+    const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}];
+    const type = runtime_1.Module.Parse('Type', code, context)[0];
+    return (type !== undefined ? (0, type_1.CreateType)(type, options) : undefined);
+}

package/build/cjs/parse/parsebox/index.d.ts

@@ -0,0 +1,2 @@
+export * as Runtime from './runtime/index';
+export * as Static from './static/index';

package/build/cjs/parse/parsebox/index.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Static = exports.Runtime = void 0;
+exports.Runtime = require("./runtime/index");
+exports.Static = require("./static/index");

package/build/cjs/parse/parsebox/runtime/guard.d.ts

@@ -0,0 +1,17 @@
+import { IIdent, INumber, IRef, IString, IConst, ITuple, IUnion } from './types';
+/** Returns true if the value is a Tuple Parser */
+export declare function IsTuple(value: unknown): value is ITuple;
+/** Returns true if the value is a Union Parser */
+export declare function IsUnion(value: unknown): value is IUnion;
+/** Returns true if the value is a Const Parser */
+export declare function IsConst(value: unknown): value is IConst;
+/** Returns true if the value is a Ident Parser */
+export declare function IsIdent(value: unknown): value is IIdent;
+/** Returns true if the value is a Number Parser */
+export declare function IsNumber(value: unknown): value is INumber;
+/** Returns true if the value is a Ref Parser */
+export declare function IsRef(value: unknown): value is IRef;
+/** Returns true if the value is a String Parser */
+export declare function IsString(value: unknown): value is IString;
+/** Returns true if the value is a Parser */
+export declare function IsParser(value: unknown): value is IUnion<unknown> | ITuple<unknown> | IConst<unknown> | IIdent<unknown> | INumber<unknown> | IRef<unknown> | IString<unknown>;

package/build/cjs/parse/parsebox/runtime/guard.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsTuple = IsTuple;
+exports.IsUnion = IsUnion;
+exports.IsConst = IsConst;
+exports.IsIdent = IsIdent;
+exports.IsNumber = IsNumber;
+exports.IsRef = IsRef;
+exports.IsString = IsString;
+exports.IsParser = IsParser;
+// ------------------------------------------------------------------
+// Value Guard
+// ------------------------------------------------------------------
+// prettier-ignore
+function HasPropertyKey(value, key) {
+    return key in value;
+}
+// prettier-ignore
+function IsObjectValue(value) {
+    return typeof value === 'object' && value !== null;
+}
+// prettier-ignore
+function IsArrayValue(value) {
+    return globalThis.Array.isArray(value);
+}
+// ------------------------------------------------------------------
+// Parser Guard
+// ------------------------------------------------------------------
+/** Returns true if the value is a Tuple Parser */
+// prettier-ignore
+function IsTuple(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Tuple' && HasPropertyKey(value, 'parsers') && IsArrayValue(value.parsers);
+}
+/** Returns true if the value is a Union Parser */
+// prettier-ignore
+function IsUnion(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Union' && HasPropertyKey(value, 'parsers') && IsArrayValue(value.parsers);
+}
+/** Returns true if the value is a Const Parser */
+// prettier-ignore
+function IsConst(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Const' && HasPropertyKey(value, 'value') && typeof value.value === 'string';
+}
+/** Returns true if the value is a Ident Parser */
+// prettier-ignore
+function IsIdent(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Ident';
+}
+/** Returns true if the value is a Number Parser */
+// prettier-ignore
+function IsNumber(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Number';
+}
+/** Returns true if the value is a Ref Parser */
+// prettier-ignore
+function IsRef(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Ref' && HasPropertyKey(value, 'ref') && typeof value.ref === 'string';
+}
+/** Returns true if the value is a String Parser */
+// prettier-ignore
+function IsString(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'String' && HasPropertyKey(value, 'options') && IsArrayValue(value.options);
+}
+/** Returns true if the value is a Parser */
+// prettier-ignore
+function IsParser(value) {
+    return (IsTuple(value) ||
+        IsUnion(value) ||
+        IsConst(value) ||
+        IsIdent(value) ||
+        IsNumber(value) ||
+        IsRef(value) ||
+        IsString(value));
+}

package/build/cjs/parse/parsebox/runtime/index.d.ts

@@ -0,0 +1,5 @@
+export * as Guard from './guard';
+export * as Token from './token';
+export * from './types';
+export * from './module';
+export * from './parse';

package/build/cjs/parse/parsebox/runtime/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+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 });
+exports.Token = exports.Guard = void 0;
+exports.Guard = require("./guard");
+exports.Token = require("./token");
+__exportStar(require("./types"), exports);
+__exportStar(require("./module"), exports);
+__exportStar(require("./parse"), exports);

package/build/cjs/parse/parsebox/runtime/module.d.ts

@@ -0,0 +1,9 @@
+import * as Types from './types';
+export declare class Module<Properties extends Types.IModuleProperties = Types.IModuleProperties> {
+    private readonly properties;
+    constructor(properties: Properties);
+    /** Parses using one of the parsers defined on this instance */
+    Parse<Key extends keyof Properties>(key: Key, code: string, context: unknown): [] | [Types.StaticParser<Properties[Key]>, string];
+    /** Parses using one of the parsers defined on this instance */
+    Parse<Key extends keyof Properties>(key: Key, code: string): [] | [Types.StaticParser<Properties[Key]>, string];
+}

package/build/cjs/parse/parsebox/runtime/module.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = void 0;
+const parse_1 = require("./parse");
+// ------------------------------------------------------------------
+// Module
+// ------------------------------------------------------------------
+// prettier-ignore
+class Module {
+    constructor(properties) {
+        this.properties = properties;
+    }
+    /** Parses using one of the parsers defined on this instance */
+    Parse(...args) {
+        const [key, code, context] = args.length === 3 ? [args[0], args[1], args[2]] :
+            args.length === 2 ? [args[0], args[1], undefined] :
+                (() => { throw Error('Invalid parse arguments'); })();
+        return (0, parse_1.Parse)(this.properties[key], this.properties, code, context);
+    }
+}
+exports.Module = Module;

package/build/cjs/parse/parsebox/runtime/parse.d.ts

@@ -0,0 +1,9 @@
+import * as Types from './types';
+/** Parses content using the given parser */
+export declare function Parse<Parser extends Types.IParser>(parser: Parser, properties: Types.IModuleProperties, code: string, context: unknown): [] | [Types.StaticParser<Parser>, string];
+/** Parses content using the given parser */
+export declare function Parse<Parser extends Types.IParser>(parser: Parser, properties: Types.IModuleProperties, code: string): [] | [Types.StaticParser<Parser>, string];
+/** Parses content using the given parser */
+export declare function Parse<Parser extends Types.IParser>(parser: Parser, code: string, context: unknown): [] | [Types.StaticParser<Parser>, string];
+/** Parses content using the given parser */
+export declare function Parse<Parser extends Types.IParser>(parser: Parser, code: string): [] | [Types.StaticParser<Parser>, string];

package/build/cjs/parse/parsebox/runtime/parse.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parse = Parse;
+const Guard = require("./guard");
+const Token = require("./token");
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseTuple(parsers, properties, code, context) {
+    const buffer = [];
+    let rest = code;
+    for (const parser of parsers) {
+        const result = ParseParser(parser, properties, rest, context);
+        if (result.length === 0)
+            return [];
+        buffer.push(result[0]);
+        rest = result[1];
+    }
+    return [buffer, rest];
+}
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseUnion(parsers, properties, code, context) {
+    for (const parser of parsers) {
+        const result = ParseParser(parser, properties, code, context);
+        if (result.length === 0)
+            continue;
+        return result;
+    }
+    return [];
+}
+// ------------------------------------------------------------------
+// Const
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseConst(value, code, context) {
+    return Token.Const(value, code);
+}
+// ------------------------------------------------------------------
+// Ref
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseRef(ref, properties, code, context) {
+    const parser = properties[ref];
+    if (!Guard.IsParser(parser))
+        throw Error(`Cannot dereference parser '${ref}'`);
+    return ParseParser(parser, properties, code, context);
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseString(options, code, _context) {
+    return Token.String(options, code);
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseNumber(code, _context) {
+    return Token.Number(code);
+}
+// ------------------------------------------------------------------
+// Ident
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseIdent(code, _context) {
+    return Token.Ident(code);
+}
+// ------------------------------------------------------------------
+// Parser
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseParser(parser, properties, code, context) {
+    const result = (Guard.IsTuple(parser) ? ParseTuple(parser.parsers, properties, code, context) :
+        Guard.IsUnion(parser) ? ParseUnion(parser.parsers, properties, code, context) :
+            Guard.IsConst(parser) ? ParseConst(parser.value, code, context) :
+                Guard.IsRef(parser) ? ParseRef(parser.ref, properties, code, context) :
+                    Guard.IsString(parser) ? ParseString(parser.options, code, context) :
+                        Guard.IsIdent(parser) ? ParseIdent(code, context) :
+                            Guard.IsNumber(parser) ? ParseNumber(code, context) :
+                                []);
+    return (result.length === 2
+        ? [parser.mapping(result[0], context), result[1]]
+        : result);
+}
+/** Parses content using the given parser */
+// prettier-ignore
+function Parse(...args) {
+    const withProperties = typeof args[1] === 'string' ? false : true;
+    const [parser, properties, code, context] = withProperties
+        ? [args[0], args[1], args[2], args[3]]
+        : [args[0], {}, args[1], args[2]];
+    return ParseParser(parser, properties, code, context);
+}

package/build/cjs/parse/parsebox/runtime/token.d.ts

@@ -0,0 +1,8 @@
+/** Takes the next constant string value skipping any whitespace */
+export declare function Const(value: string, code: string): [] | [string, string];
+/** Scans for the next Ident token */
+export declare function Ident(code: string): [] | [string, string];
+/** Scans for the next number token */
+export declare function Number(code: string): [string, string] | [];
+/** Scans the next Literal String value */
+export declare function String(options: string[], code: string): [string, string] | [];

package/build/cjs/parse/parsebox/runtime/token.js

@@ -0,0 +1,230 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Const = Const;
+exports.Ident = Ident;
+exports.Number = Number;
+exports.String = String;
+// ------------------------------------------------------------------
+// Chars
+// ------------------------------------------------------------------
+// prettier-ignore
+var Chars;
+(function (Chars) {
+    /** Returns true if the char code is a whitespace */
+    function IsWhitespace(value) {
+        return value === 32;
+    }
+    Chars.IsWhitespace = IsWhitespace;
+    /** Returns true if the char code is a newline */
+    function IsNewline(value) {
+        return value === 10;
+    }
+    Chars.IsNewline = IsNewline;
+    /** Returns true if the char code is a alpha  */
+    function IsAlpha(value) {
+        return ((value >= 65 && value <= 90) || // A-Z 
+            (value >= 97 && value <= 122) // a-z
+        );
+    }
+    Chars.IsAlpha = IsAlpha;
+    /** Returns true if the char code is zero */
+    function IsZero(value) {
+        return value === 48;
+    }
+    Chars.IsZero = IsZero;
+    /** Returns true if the char code is non-zero */
+    function IsNonZero(value) {
+        return value >= 49 && value <= 57;
+    }
+    Chars.IsNonZero = IsNonZero;
+    /** Returns true if the char code is a digit */
+    function IsDigit(value) {
+        return (IsNonZero(value) ||
+            IsZero(value));
+    }
+    Chars.IsDigit = IsDigit;
+    /** Returns true if the char code is a dot */
+    function IsDot(value) {
+        return value === 46;
+    }
+    Chars.IsDot = IsDot;
+    /** Returns true if this char code is a underscore */
+    function IsUnderscore(value) {
+        return value === 95;
+    }
+    Chars.IsUnderscore = IsUnderscore;
+    /** Returns true if this char code is a dollar sign */
+    function IsDollarSign(value) {
+        return value === 36;
+    }
+    Chars.IsDollarSign = IsDollarSign;
+})(Chars || (Chars = {}));
+// ------------------------------------------------------------------
+// Trim
+// ------------------------------------------------------------------
+// prettier-ignore
+var Trim;
+(function (Trim) {
+    /** Trims Whitespace and retains Newline, Tabspaces, etc. */
+    function TrimWhitespaceOnly(code) {
+        for (let i = 0; i < code.length; i++) {
+            if (Chars.IsWhitespace(code.charCodeAt(i)))
+                continue;
+            return code.slice(i);
+        }
+        return code;
+    }
+    Trim.TrimWhitespaceOnly = TrimWhitespaceOnly;
+    /** Trims Whitespace including Newline, Tabspaces, etc. */
+    function TrimAll(code) {
+        return code.trimStart();
+    }
+    Trim.TrimAll = TrimAll;
+})(Trim || (Trim = {}));
+// ------------------------------------------------------------------
+// Const
+// ------------------------------------------------------------------
+/** Checks the value matches the next string  */
+// prettier-ignore
+function NextTokenCheck(value, code) {
+    if (value.length > code.length)
+        return false;
+    for (let i = 0; i < value.length; i++) {
+        if (value.charCodeAt(i) !== code.charCodeAt(i))
+            return false;
+    }
+    return true;
+}
+/** Gets the next constant string value or empty if no match */
+// prettier-ignore
+function NextConst(value, code) {
+    return NextTokenCheck(value, code)
+        ? [code.slice(0, value.length), code.slice(value.length)]
+        : [];
+}
+/** Takes the next constant string value skipping any whitespace */
+// prettier-ignore
+function Const(value, code) {
+    if (value.length === 0)
+        return ['', code];
+    const char_0 = value.charCodeAt(0);
+    return (Chars.IsNewline(char_0) ? NextConst(value, Trim.TrimWhitespaceOnly(code)) :
+        Chars.IsWhitespace(char_0) ? NextConst(value, code) :
+            NextConst(value, Trim.TrimAll(code)));
+}
+// ------------------------------------------------------------------
+// Ident
+// ------------------------------------------------------------------
+// prettier-ignore
+function IdentIsFirst(char) {
+    return (Chars.IsAlpha(char) ||
+        Chars.IsDollarSign(char) ||
+        Chars.IsUnderscore(char));
+}
+// prettier-ignore
+function IdentIsRest(char) {
+    return (Chars.IsAlpha(char) ||
+        Chars.IsDigit(char) ||
+        Chars.IsDollarSign(char) ||
+        Chars.IsUnderscore(char));
+}
+// prettier-ignore
+function NextIdent(code) {
+    if (!IdentIsFirst(code.charCodeAt(0)))
+        return [];
+    for (let i = 1; i < code.length; i++) {
+        const char = code.charCodeAt(i);
+        if (IdentIsRest(char))
+            continue;
+        const slice = code.slice(0, i);
+        const rest = code.slice(i);
+        return [slice, rest];
+    }
+    return [code, ''];
+}
+/** Scans for the next Ident token */
+// prettier-ignore
+function Ident(code) {
+    return NextIdent(Trim.TrimAll(code));
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+/** Checks that the next number is not a leading zero */
+// prettier-ignore
+function NumberLeadingZeroCheck(code, index) {
+    const char_0 = code.charCodeAt(index + 0);
+    const char_1 = code.charCodeAt(index + 1);
+    return ((
+    // 1-9
+    Chars.IsNonZero(char_0)) || (
+    // 0
+    Chars.IsZero(char_0) &&
+        !Chars.IsDigit(char_1)) || (
+    // 0.
+    Chars.IsZero(char_0) &&
+        Chars.IsDot(char_1)) || (
+    // .0
+    Chars.IsDot(char_0) &&
+        Chars.IsDigit(char_1)));
+}
+/** Gets the next number token */
+// prettier-ignore
+function NextNumber(code) {
+    const negated = code.charAt(0) === '-';
+    const index = negated ? 1 : 0;
+    if (!NumberLeadingZeroCheck(code, index)) {
+        return [];
+    }
+    const dash = negated ? '-' : '';
+    let hasDot = false;
+    for (let i = index; i < code.length; i++) {
+        const char_i = code.charCodeAt(i);
+        if (Chars.IsDigit(char_i)) {
+            continue;
+        }
+        if (Chars.IsDot(char_i)) {
+            if (hasDot) {
+                const slice = code.slice(index, i);
+                const rest = code.slice(i);
+                return [`${dash}${slice}`, rest];
+            }
+            hasDot = true;
+            continue;
+        }
+        const slice = code.slice(index, i);
+        const rest = code.slice(i);
+        return [`${dash}${slice}`, rest];
+    }
+    return [code, ''];
+}
+/** Scans for the next number token */
+// prettier-ignore
+function Number(code) {
+    return NextNumber(Trim.TrimAll(code));
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+// prettier-ignore
+function NextString(options, code) {
+    const first = code.charAt(0);
+    if (!options.includes(first))
+        return [];
+    const quote = first;
+    for (let i = 1; i < code.length; i++) {
+        const char = code.charAt(i);
+        if (char === quote) {
+            const slice = code.slice(1, i);
+            const rest = code.slice(i + 1);
+            return [slice, rest];
+        }
+    }
+    return [];
+}
+/** Scans the next Literal String value */
+// prettier-ignore
+function String(options, code) {
+    return NextString(options, Trim.TrimAll(code));
+}