typebox 1.0.33 → 1.0.34

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "A Runtime Type System for JavaScript",
-  "version": "1.0.33",
+  "version": "1.0.34",
   "keywords": [
     "typescript",
     "jsonschema"
@@ -12,112 +12,75 @@
     "type": "git",
     "url": "https://github.com/sinclairzx81/typebox"
   },
-  "type": "commonjs",
-  "types": "./build/cjs/index.d.ts",
-  "main": "./build/cjs/index.js",
-  "module": "./build/esm/index.mjs",
+  "type": "module",
+  "types": "./build/index.d.mts",
+  "module": "./build/index.mjs",
   "exports": {
     "./guard": {
-      "require": {
-        "default": "./build/cjs/guard/index.js"
-      },
-      "import": {
-        "default": "./build/esm/guard/index.mjs"
-      }
+      "import": "./build/guard/index.mjs",
+      "default": "./build/guard/index.mjs"
     },
     "./schema": {
-      "require": {
-        "default": "./build/cjs/schema/index.js"
-      },
-      "import": {
-        "default": "./build/esm/schema/index.mjs"
-      }
+      "import": "./build/schema/index.mjs",
+      "default": "./build/schema/index.mjs"
     },
     "./value": {
-      "require": {
-        "default": "./build/cjs/value/index.js"
-      },
-      "import": {
-        "default": "./build/esm/value/index.mjs"
-      }
+      "import": "./build/value/index.mjs",
+      "default": "./build/value/index.mjs"
     },
     "./format": {
-      "require": {
-        "default": "./build/cjs/format/index.js"
-      },
-      "import": {
-        "default": "./build/esm/format/index.mjs"
-      }
+      "import": "./build/format/index.mjs",
+      "default": "./build/format/index.mjs"
     },
     "./type": {
-      "require": {
-        "default": "./build/cjs/type/index.js"
-      },
-      "import": {
-        "default": "./build/esm/type/index.mjs"
-      }
+      "import": "./build/type/index.mjs",
+      "default": "./build/type/index.mjs"
     },
     "./error": {
-      "require": {
-        "default": "./build/cjs/error/index.js"
-      },
-      "import": {
-        "default": "./build/esm/error/index.mjs"
-      }
+      "import": "./build/error/index.mjs",
+      "default": "./build/error/index.mjs"
     },
     "./system": {
-      "require": {
-        "default": "./build/cjs/system/index.js"
-      },
-      "import": {
-        "default": "./build/esm/system/index.mjs"
-      }
+      "import": "./build/system/index.mjs",
+      "default": "./build/system/index.mjs"
     },
     "./compile": {
-      "require": {
-        "default": "./build/cjs/compile/index.js"
-      },
-      "import": {
-        "default": "./build/esm/compile/index.mjs"
-      }
+      "import": "./build/compile/index.mjs",
+      "default": "./build/compile/index.mjs"
     },
     ".": {
-      "require": {
-        "default": "./build/cjs/index.js"
-      },
-      "import": {
-        "default": "./build/esm/index.mjs"
-      }
+      "import": "./build/index.mjs",
+      "default": "./build/index.mjs"
     }
   },
   "typesVersions": {
     "*": {
       "guard": [
-        "./build/esm/guard/index.d.mts"
+        "./build/guard/index.d.mts"
       ],
       "schema": [
-        "./build/esm/schema/index.d.mts"
+        "./build/schema/index.d.mts"
       ],
       "value": [
-        "./build/esm/value/index.d.mts"
+        "./build/value/index.d.mts"
       ],
       "format": [
-        "./build/esm/format/index.d.mts"
+        "./build/format/index.d.mts"
       ],
       "type": [
-        "./build/esm/type/index.d.mts"
+        "./build/type/index.d.mts"
       ],
       "error": [
-        "./build/esm/error/index.d.mts"
+        "./build/error/index.d.mts"
       ],
       "system": [
-        "./build/esm/system/index.d.mts"
+        "./build/system/index.d.mts"
       ],
       "compile": [
-        "./build/esm/compile/index.d.mts"
+        "./build/compile/index.d.mts"
       ],
       ".": [
-        "./build/esm/index.d.mts"
+        "./build/index.d.mts"
       ]
     }
   }

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

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

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

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

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

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

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

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

@@ -1,96 +0,0 @@
-"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.d.ts

@@ -1,214 +0,0 @@
-export type TValidationError = TAdditionalPropertiesError | TAnyOfError | TBooleanError | TConstError | TContainsError | TDependenciesError | TDependentRequiredError | TEnumError | TExclusiveMaximumError | TExclusiveMinimumError | TFormatError | TGuardError | TIfError | TMaximumError | TMaxItemsError | TMaxLengthError | TMaxPropertiesError | TMinimumError | TMinItemsError | TMinLengthError | TMinPropertiesError | TMultipleOfError | TNotError | TOneOfError | TPatternError | TPropertyNamesError | TRefineError | TRequiredError | TTypeError | TUnevaluatedItemsError | TUnevaluatedPropertiesError | TUniqueItemsError;
-export declare function IsValidationError(value: unknown): value is TValidationError;
-export type TLocalizedValidationError = TValidationError & {
-    message: string;
-};
-export declare function IsLocalizedValidationError(value: unknown): value is TLocalizedValidationError;
-export type TLocalizedValidationMessageCallback = (error: TValidationError) => string;
-export interface TValidationErrorBase {
-    keyword: string;
-    schemaPath: string;
-    instancePath: string;
-    params: object;
-}
-export interface TAdditionalPropertiesError extends TValidationErrorBase {
-    keyword: 'additionalProperties';
-    params: {
-        additionalProperties: string[];
-    };
-}
-export interface TAnyOfError extends TValidationErrorBase {
-    keyword: 'anyOf';
-    params: {};
-}
-export interface TBooleanError extends TValidationErrorBase {
-    keyword: 'boolean';
-    params: {};
-}
-export interface TConstError extends TValidationErrorBase {
-    keyword: 'const';
-    params: {
-        allowedValue: unknown;
-    };
-}
-export interface TContainsError extends TValidationErrorBase {
-    keyword: 'contains';
-    params: {
-        minContains: number;
-        maxContains?: number;
-    };
-}
-export interface TDependenciesError extends TValidationErrorBase {
-    keyword: 'dependencies';
-    params: {
-        property: string;
-        dependencies: string[];
-    };
-}
-export interface TDependentRequiredError extends TValidationErrorBase {
-    keyword: 'dependentRequired';
-    params: {
-        property: string;
-        dependencies: string[];
-    };
-}
-export interface TEnumError extends TValidationErrorBase {
-    keyword: 'enum';
-    params: {
-        allowedValues: unknown[];
-    };
-}
-export interface TExclusiveMaximumError extends TValidationErrorBase {
-    keyword: 'exclusiveMaximum';
-    params: {
-        comparison: '<';
-        limit: number | bigint;
-    };
-}
-export interface TExclusiveMinimumError extends TValidationErrorBase {
-    keyword: 'exclusiveMinimum';
-    params: {
-        comparison: '>';
-        limit: number | bigint;
-    };
-}
-export interface TFormatError extends TValidationErrorBase {
-    keyword: 'format';
-    params: {
-        format: string;
-    };
-}
-export interface TGuardError extends TValidationErrorBase {
-    keyword: '~guard';
-    params: {
-        errors: object[];
-    };
-}
-export interface TIfError extends TValidationErrorBase {
-    keyword: 'if';
-    params: {
-        failingKeyword: 'then' | 'else';
-    };
-}
-export interface TMaximumError extends TValidationErrorBase {
-    keyword: 'maximum';
-    params: {
-        comparison: '<=';
-        limit: number | bigint;
-    };
-}
-export interface TMaxItemsError extends TValidationErrorBase {
-    keyword: 'maxItems';
-    params: {
-        limit: number;
-    };
-}
-export interface TMaxLengthError extends TValidationErrorBase {
-    keyword: 'maxLength';
-    params: {
-        limit: number;
-    };
-}
-export interface TMaxPropertiesError extends TValidationErrorBase {
-    keyword: 'maxProperties';
-    params: {
-        limit: number;
-    };
-}
-export interface TMinimumError extends TValidationErrorBase {
-    keyword: 'minimum';
-    params: {
-        comparison: '>=';
-        limit: number | bigint;
-    };
-}
-export interface TMinItemsError extends TValidationErrorBase {
-    keyword: 'minItems';
-    params: {
-        limit: number;
-    };
-}
-export interface TMinLengthError extends TValidationErrorBase {
-    keyword: 'minLength';
-    params: {
-        limit: number;
-    };
-}
-export interface TMinPropertiesError extends TValidationErrorBase {
-    keyword: 'minProperties';
-    params: {
-        limit: number;
-    };
-}
-export interface TMultipleOfError extends TValidationErrorBase {
-    keyword: 'multipleOf';
-    params: {
-        multipleOf: number | bigint;
-    };
-}
-export interface TMinimumError extends TValidationErrorBase {
-    keyword: 'minimum';
-    params: {
-        comparison: '>=';
-        limit: number | bigint;
-    };
-}
-export interface TNotError extends TValidationErrorBase {
-    keyword: 'not';
-    params: {};
-}
-export interface TOneOfError extends TValidationErrorBase {
-    keyword: 'oneOf';
-    params: {
-        passingSchemas: number[];
-    };
-}
-export interface TPatternError extends TValidationErrorBase {
-    keyword: 'pattern';
-    params: {
-        pattern: string | RegExp;
-    };
-}
-export interface TPropertyNamesError extends TValidationErrorBase {
-    keyword: 'propertyNames';
-    params: {
-        propertyNames: string[];
-    };
-}
-export interface TRefineError extends TValidationErrorBase {
-    keyword: '~refine';
-    params: {
-        index: number;
-        message: string;
-    };
-}
-export interface TRequiredError extends TValidationErrorBase {
-    keyword: 'required';
-    params: {
-        requiredProperties: string[];
-    };
-}
-export interface TTypeError extends TValidationErrorBase {
-    keyword: 'type';
-    params: {
-        type: string | string[];
-    };
-}
-export interface TUnevaluatedItemsError extends TValidationErrorBase {
-    keyword: 'unevaluatedItems';
-    params: {
-        unevaluatedItems: number[];
-    };
-}
-export interface TUnevaluatedPropertiesError extends TValidationErrorBase {
-    keyword: 'unevaluatedProperties';
-    params: {
-        unevaluatedProperties: PropertyKey[];
-    };
-}
-export interface TUniqueItemsError extends TValidationErrorBase {
-    keyword: 'uniqueItems';
-    params: {
-        duplicateItems: number[];
-    };
-}

package/build/cjs/error/errors.js

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

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