typebox 1.0.31 → 1.0.33

package/build/cjs/compile/code.d.ts

@@ -0,0 +1,12 @@
+import { type TProperties, type TSchema } from '../type/index';
+import { type TExternal } from '../schema/index';
+export interface CodeResult {
+    /** External Variables  */
+    External: TExternal;
+    /** Generated Esm module. */
+    Code: string;
+}
+/** Creates a standalone ESM validation module for the given type. */
+export declare function Code<Type extends TSchema>(type: Type): CodeResult;
+/** Creates a standalone ESM validation module for the given type. */
+export declare function Code<Context extends TProperties, Type extends TSchema>(context: Context, type: Type): CodeResult;

package/build/cjs/compile/code.js

@@ -0,0 +1,68 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Code = Code;
+const index_1 = require("../system/arguments/index");
+const index_2 = require("../schema/index");
+// ------------------------------------------------------------------
+// Comments and Formatting
+// ------------------------------------------------------------------
+function TsIgnore() {
+    return `// @ts-ignore`;
+}
+function Separator() {
+    return ``;
+}
+// ------------------------------------------------------------------
+// ImportSection
+// ------------------------------------------------------------------
+function ImportSection(build) {
+    const context = build.UseUnevaluated() ? [`import { CheckContext } from "typebox/schema"`] : [];
+    const hashing = `import { Hashing } from "typebox/system"`;
+    const format = `import { Format } from "typebox/format"`;
+    const guard = `import { Guard } from "typebox/guard"`;
+    return [...context, hashing, format, guard];
+}
+// ------------------------------------------------------------------
+// ExternalSection
+// ------------------------------------------------------------------
+function ExternalSection(build) {
+    const { identifier } = build.External();
+    return [
+        Separator(),
+        TsIgnore(),
+        `let ${identifier} = []`,
+        Separator(),
+        TsIgnore(),
+        `export function SetExternal(external) { ${identifier} = external.variables }`
+    ];
+}
+// ------------------------------------------------------------------
+// FunctionSection
+// ------------------------------------------------------------------
+function FunctionSection(build) {
+    return build.Functions().map((func) => [Separator(), TsIgnore(), `${func};`].join('\n'));
+}
+// ------------------------------------------------------------------
+// ExportSection
+// ------------------------------------------------------------------
+function ExportSection(build) {
+    const body = build.UseUnevaluated()
+        ? `const context = new CheckContext({}, {}); return ${build.Call()}`
+        : `return ${build.Call()}`;
+    return [
+        Separator(),
+        TsIgnore(),
+        `export function Check(value) { ${body} }`
+    ];
+}
+/** Creates a standalone ESM validation module for the given type. */
+function Code(...args) {
+    const [context, type] = index_1.Arguments.Match(args, {
+        2: (context, type) => [context, type],
+        1: (type) => [{}, type]
+    });
+    const build = (0, index_2.Build)(context, type);
+    const code = [...ImportSection(build), ...ExternalSection(build), ...FunctionSection(build), ...ExportSection(build)].join('\n');
+    return { External: build.External(), Code: code };
+}

package/build/cjs/compile/compile.d.ts

@@ -0,0 +1,6 @@
+import { type TProperties, type TSchema } from '../type/index';
+import { Validator } from './validator';
+/** Compiles a type into a high performance Validator */
+export declare function Compile<const Type extends TSchema>(type: Type): Validator<{}, Type>;
+/** Compiles a type into a high performance Validator */
+export declare function Compile<Context extends TProperties, const Type extends TSchema>(context: Context, type: Type): Validator<Context, Type>;

package/build/cjs/compile/compile.js

@@ -0,0 +1,14 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Compile = Compile;
+const index_1 = require("../system/arguments/index");
+const validator_1 = require("./validator");
+/** Compiles a type into a high performance Validator */
+function Compile(...args) {
+    const [context, type] = index_1.Arguments.Match(args, {
+        2: (context, type) => [context, type],
+        1: (type) => [{}, type]
+    });
+    return new validator_1.Validator(context, type);
+}

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

@@ -0,0 +1,12 @@
+export * from './code';
+export * from './compile';
+export * from './validator';
+import { Code } from './code';
+import { Compile } from './compile';
+import { Validator } from './validator';
+declare const _default: {
+    Code: typeof Code;
+    Compile: typeof Compile;
+    Validator: typeof Validator;
+};
+export default _default;

package/build/cjs/compile/index.js

@@ -0,0 +1,29 @@
+"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 });
+// ------------------------------------------------------------------
+// Barrel
+// ------------------------------------------------------------------
+__exportStar(require("./code"), exports);
+__exportStar(require("./compile"), exports);
+__exportStar(require("./validator"), exports);
+// ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
+const code_1 = require("./code");
+const compile_1 = require("./compile");
+const validator_1 = require("./validator");
+exports.default = { Code: code_1.Code, Compile: compile_1.Compile, Validator: validator_1.Validator };

package/build/cjs/compile/validator.d.ts

@@ -0,0 +1,37 @@
+import { type TLocalizedValidationError } from '../error/index';
+import { type StaticDecode, type StaticEncode, type TProperties, type TSchema, Base } from '../type/index';
+export declare class Validator<Context extends TProperties = TProperties, Type extends TSchema = TSchema> extends Base<StaticEncode<Type, Context>> {
+    private readonly context;
+    private readonly type;
+    private readonly isEvaluated;
+    private readonly hasCodec;
+    private readonly code;
+    private readonly check;
+    constructor(context: Context, type: Type);
+    /** Returns true if this validator is using runtime eval optimizations */
+    IsEvaluated(): boolean;
+    /** Returns the Context for this validator */
+    Context(): Context;
+    /** Returns the Type for this validator */
+    Type(): Type;
+    /** Returns the generated code for this validator */
+    Code(): string;
+    /** Checks a value matches the Validator type. */
+    Check(value: unknown): value is StaticEncode<Type, Context>;
+    /** Returns errors for the given value. */
+    Errors(value: unknown): TLocalizedValidationError[];
+    /** Cleans a value using the Validator type. */
+    Clean(value: unknown): unknown;
+    /** Converts a value using the Validator type. */
+    Convert(value: unknown): unknown;
+    /** Creates a value using the Validator type. */
+    Create(): StaticEncode<Type, Context>;
+    /** Creates defaults using the Validator type. */
+    Default(value: unknown): unknown;
+    /** Parses a value */
+    Parse(value: unknown): StaticDecode<Type, Context>;
+    /** Decodes a value */
+    Decode(value: unknown): StaticDecode<Type, Context>;
+    /** Encodes a value */
+    Encode(value: unknown): StaticEncode<Type, Context>;
+}

package/build/cjs/compile/validator.js

@@ -0,0 +1,96 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = void 0;
+const index_1 = require("../system/environment/index");
+const index_2 = require("../type/index");
+const index_3 = require("../value/index");
+const index_4 = require("../schema/index");
+// ------------------------------------------------------------------
+// ValidatorType<...>
+// ------------------------------------------------------------------
+class Validator extends index_2.Base {
+    constructor(context, type) {
+        super();
+        this.context = context;
+        this.type = type;
+        const result = (0, index_4.Build)(context, type).Evaluate();
+        this.hasCodec = (0, index_3.HasCodec)(context, type);
+        this.isEvaluated = result.IsEvaluated;
+        this.code = result.Code;
+        this.check = result.Check;
+    }
+    // ----------------------------------------------------------------
+    // Evaluated
+    // ----------------------------------------------------------------
+    /** Returns true if this validator is using runtime eval optimizations */
+    IsEvaluated() {
+        return this.isEvaluated;
+    }
+    // ----------------------------------------------------------------
+    // Schema
+    // ----------------------------------------------------------------
+    /** Returns the Context for this validator */
+    Context() {
+        return this.context;
+    }
+    /** Returns the Type for this validator */
+    Type() {
+        return this.type;
+    }
+    // ----------------------------------------------------------------
+    // Code
+    // ----------------------------------------------------------------
+    /** Returns the generated code for this validator */
+    Code() {
+        return this.code;
+    }
+    // ----------------------------------------------------------------
+    // Base<...>
+    // ----------------------------------------------------------------
+    /** Checks a value matches the Validator type. */
+    Check(value) {
+        return this.check(value);
+    }
+    /** Returns errors for the given value. */
+    Errors(value) {
+        if (index_1.Environment.CanEvaluate() && this.check(value))
+            return [];
+        return (0, index_3.Errors)(this.context, this.type, value);
+    }
+    /** Cleans a value using the Validator type. */
+    Clean(value) {
+        return (0, index_3.Clean)(this.context, this.type, value);
+    }
+    /** Converts a value using the Validator type. */
+    Convert(value) {
+        return (0, index_3.Convert)(this.context, this.type, value);
+    }
+    /** Creates a value using the Validator type. */
+    Create() {
+        return (0, index_3.Create)(this.context, this.type);
+    }
+    /** Creates defaults using the Validator type. */
+    Default(value) {
+        return (0, index_3.Default)(this.context, this.type, value);
+    }
+    // ----------------------------------------------------------------
+    // Parse | Decode | Encode
+    // ----------------------------------------------------------------
+    /** Parses a value */
+    Parse(value) {
+        const result = this.Check(value) ? value : (0, index_3.Parser)(this.context, this.type, value);
+        return result;
+    }
+    /** Decodes a value */
+    Decode(value) {
+        const result = this.hasCodec ? (0, index_3.Decode)(this.context, this.type, value) : this.Parse(value);
+        return result;
+    }
+    /** Encodes a value */
+    Encode(value) {
+        const result = this.hasCodec ? (0, index_3.Encode)(this.context, this.type, value) : this.Parse(value);
+        return result;
+    }
+}
+exports.Validator = Validator;

package/build/cjs/error/errors.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsValidationError = IsValidationError;
+exports.IsLocalizedValidationError = IsLocalizedValidationError;
+const index_1 = require("../guard/index");
+function IsValidationError(value) {
+    return index_1.Guard.IsObject(value) &&
+        index_1.Guard.HasPropertyKey(value, 'keyword') &&
+        index_1.Guard.HasPropertyKey(value, 'schemaPath') &&
+        index_1.Guard.HasPropertyKey(value, 'instancePath') &&
+        index_1.Guard.HasPropertyKey(value, 'params') &&
+        index_1.Guard.IsString(value.keyword) &&
+        index_1.Guard.IsString(value.schemaPath) &&
+        index_1.Guard.IsString(value.instancePath) &&
+        index_1.Guard.IsObject(value.params);
+}
+function IsLocalizedValidationError(value) {
+    return IsValidationError(value) &&
+        index_1.Guard.HasPropertyKey(value, 'message') &&
+        index_1.Guard.IsString(value.message);
+}

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

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

package/build/cjs/error/index.js

@@ -0,0 +1,17 @@
+"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("./errors"), exports);

package/build/cjs/format/_registry.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Clear = Clear;
+exports.Entries = Entries;
+exports.Set = Set;
+exports.Has = Has;
+exports.Get = Get;
+exports.Test = Test;
+exports.Reset = Reset;
+const date_time_1 = require("./date-time");
+const date_1 = require("./date");
+const duration_1 = require("./duration");
+const email_1 = require("./email");
+const hostname_1 = require("./hostname");
+const idn_email_1 = require("./idn-email");
+const idn_hostname_1 = require("./idn-hostname");
+const ipv4_1 = require("./ipv4");
+const ipv6_1 = require("./ipv6");
+const iri_reference_1 = require("./iri-reference");
+const iri_1 = require("./iri");
+const json_pointer_uri_fragment_1 = require("./json-pointer-uri-fragment");
+const json_pointer_1 = require("./json-pointer");
+const regex_1 = require("./regex");
+const relative_json_pointer_1 = require("./relative-json-pointer");
+const time_1 = require("./time");
+const uri_reference_1 = require("./uri-reference");
+const uri_template_1 = require("./uri-template");
+const uri_1 = require("./uri");
+const url_1 = require("./url");
+const uuid_1 = require("./uuid");
+// ------------------------------------------------------------------
+// Formats
+// ------------------------------------------------------------------
+const formats = new Map();
+// ------------------------------------------------------------------
+// Clear
+// ------------------------------------------------------------------
+/** Clears all entries */
+function Clear() {
+    formats.clear();
+}
+// ------------------------------------------------------------------
+// Entries
+// ------------------------------------------------------------------
+/** Returns format entries in this registry */
+function Entries() {
+    return [...formats.entries()];
+}
+// ------------------------------------------------------------------
+// Set
+// ------------------------------------------------------------------
+/** Sets a format */
+function Set(format, check) {
+    formats.set(format, check);
+}
+// ------------------------------------------------------------------
+// Has
+// ------------------------------------------------------------------
+/** Returns true if the registry has this format */
+function Has(format) {
+    return formats.has(format);
+}
+// ------------------------------------------------------------------
+// Get
+// ------------------------------------------------------------------
+/** Gets a format or undefined if not exists */
+function Get(format) {
+    return formats.get(format);
+}
+// ------------------------------------------------------------------
+// Test
+// ------------------------------------------------------------------
+/** Tests a value against a format, if the format is not registered, true */
+function Test(format, value) {
+    return formats.get(format)?.(value) ?? true;
+}
+// ------------------------------------------------------------------
+// Reset
+// ------------------------------------------------------------------
+/** Resets all formats to defaults */
+function Reset() {
+    Clear();
+    formats.set('date-time', date_time_1.IsDateTime);
+    formats.set('date', date_1.IsDate);
+    formats.set('duration', duration_1.IsDuration);
+    formats.set('email', email_1.IsEmail);
+    formats.set('hostname', hostname_1.IsHostname);
+    formats.set('idn-email', idn_email_1.IsIdnEmail);
+    formats.set('idn-hostname', idn_hostname_1.IsIdnHostname);
+    formats.set('ipv4', ipv4_1.IsIPv4);
+    formats.set('ipv6', ipv6_1.IsIPv6);
+    formats.set('iri-reference', iri_reference_1.IsIriReference);
+    formats.set('iri', iri_1.IsIri);
+    formats.set('json-pointer-uri-fragment', json_pointer_uri_fragment_1.IsJsonPointerUriFragment);
+    formats.set('json-pointer', json_pointer_1.IsJsonPointer);
+    formats.set('regex', regex_1.IsRegex);
+    formats.set('relative-json-pointer', relative_json_pointer_1.IsRelativeJsonPointer);
+    formats.set('time', time_1.IsTime);
+    formats.set('uri-reference', uri_reference_1.IsUriReference);
+    formats.set('uri-template', uri_template_1.IsUriTemplate);
+    formats.set('uri', uri_1.IsUri);
+    formats.set('url', url_1.IsUrl);
+    formats.set('uuid', uuid_1.IsUuid);
+}
+Reset();

package/build/cjs/format/date-time.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsDateTime = IsDateTime;
+const date_1 = require("./date");
+const time_1 = require("./time");
+/**
+ * Returns true if the value is a ISO8601 DateTime string
+ * @source ajv-formats
+ * @example `2020-12-12T20:20:40+00:00`
+ */
+function IsDateTime(value, strictTimeZone = true) {
+    const dateTime = value.split(/T/i);
+    return dateTime.length === 2 && (0, date_1.IsDate)(dateTime[0]) && (0, time_1.IsTime)(dateTime[1], strictTimeZone);
+}

package/build/cjs/format/date.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsDate = IsDate;
+const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+function IsLeapYear(year) {
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+/**
+ * Returns true if the value is a ISO8601 Date component string
+ * @source ajv-formats
+ * @example `2020-12-12`
+ */
+function IsDate(value) {
+    const matches = DATE.exec(value);
+    if (!matches)
+        return false;
+    const year = +matches[1];
+    const month = +matches[2];
+    const day = +matches[3];
+    return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && IsLeapYear(year) ? 29 : DAYS[month]);
+}

package/build/cjs/format/duration.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsDuration = IsDuration;
+const Duration = /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/;
+/**
+ * Returns true if the value is a Duration string
+ * @source ajv-formats
+ */
+function IsDuration(value) {
+    return Duration.test(value);
+}

package/build/cjs/format/email.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsEmail = IsEmail;
+const Email = /^(?!.*\.\.)[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i;
+/** Returns true if the value is an Email */
+function IsEmail(value) {
+    return Email.test(value);
+}

package/build/cjs/format/format.d.ts

@@ -0,0 +1,22 @@
+export * from './_registry';
+export * from './date-time';
+export * from './date';
+export * from './duration';
+export * from './email';
+export * from './hostname';
+export * from './idn-email';
+export * from './idn-hostname';
+export * from './ipv4';
+export * from './ipv6';
+export * from './iri-reference';
+export * from './iri';
+export * from './json-pointer-uri-fragment';
+export * from './json-pointer';
+export * from './regex';
+export * from './relative-json-pointer';
+export * from './time';
+export * from './uri-reference';
+export * from './uri-template';
+export * from './uri';
+export * from './url';
+export * from './uuid';

package/build/cjs/format/format.js

@@ -0,0 +1,38 @@
+"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("./_registry"), exports);
+__exportStar(require("./date-time"), exports);
+__exportStar(require("./date"), exports);
+__exportStar(require("./duration"), exports);
+__exportStar(require("./email"), exports);
+__exportStar(require("./hostname"), exports);
+__exportStar(require("./idn-email"), exports);
+__exportStar(require("./idn-hostname"), exports);
+__exportStar(require("./ipv4"), exports);
+__exportStar(require("./ipv6"), exports);
+__exportStar(require("./iri-reference"), exports);
+__exportStar(require("./iri"), exports);
+__exportStar(require("./json-pointer-uri-fragment"), exports);
+__exportStar(require("./json-pointer"), exports);
+__exportStar(require("./regex"), exports);
+__exportStar(require("./relative-json-pointer"), exports);
+__exportStar(require("./time"), exports);
+__exportStar(require("./uri-reference"), exports);
+__exportStar(require("./uri-template"), exports);
+__exportStar(require("./uri"), exports);
+__exportStar(require("./url"), exports);
+__exportStar(require("./uuid"), exports);

package/build/cjs/format/hostname.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsHostname = IsHostname;
+const Hostname = /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i;
+/** Returns true if the value is a Hostname */
+function IsHostname(value) {
+    return Hostname.test(value);
+}

package/build/cjs/format/idn-email.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsIdnEmail = IsIdnEmail;
+const IdnEmail = /^(?!.*\.\.)[\p{L}\p{N}!#$%&'*+/=?^_`{|}~-]+(?:\.[\p{L}\p{N}!#$%&'*+/=?^_`{|}~-]+)*@[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,61}[\p{L}\p{N}])?(?:\.[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,61}[\p{L}\p{N}])?)*$/iu;
+/** Returns true if the value is a Idn Email */
+function IsIdnEmail(value) {
+    return IdnEmail.test(value);
+}