typebox 1.0.31 → 1.0.33

package/build/cjs/guard/globals.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsBoolean = IsBoolean;
+exports.IsNumber = IsNumber;
+exports.IsString = IsString;
+exports.IsTypeArray = IsTypeArray;
+exports.IsInt8Array = IsInt8Array;
+exports.IsUint8Array = IsUint8Array;
+exports.IsUint8ClampedArray = IsUint8ClampedArray;
+exports.IsInt16Array = IsInt16Array;
+exports.IsUint16Array = IsUint16Array;
+exports.IsInt32Array = IsInt32Array;
+exports.IsUint32Array = IsUint32Array;
+exports.IsFloat32Array = IsFloat32Array;
+exports.IsFloat64Array = IsFloat64Array;
+exports.IsBigInt64Array = IsBigInt64Array;
+exports.IsBigUint64Array = IsBigUint64Array;
+exports.IsRegExp = IsRegExp;
+exports.IsDate = IsDate;
+exports.IsSet = IsSet;
+exports.IsMap = IsMap;
+// --------------------------------------------------------------------------
+// Primitives
+// --------------------------------------------------------------------------
+function IsBoolean(value) {
+    return value instanceof Boolean;
+}
+function IsNumber(value) {
+    return value instanceof Number;
+}
+function IsString(value) {
+    return value instanceof String;
+}
+// --------------------------------------------------------------------------
+// TypeArray
+// --------------------------------------------------------------------------
+function IsTypeArray(value) {
+    return globalThis.ArrayBuffer.isView(value);
+}
+/** Returns true if the value is a Int8Array */
+function IsInt8Array(value) {
+    return value instanceof globalThis.Int8Array;
+}
+/** Returns true if the value is a Uint8Array */
+function IsUint8Array(value) {
+    return value instanceof globalThis.Uint8Array;
+}
+/** Returns true if the value is a Uint8ClampedArray */
+function IsUint8ClampedArray(value) {
+    return value instanceof globalThis.Uint8ClampedArray;
+}
+/** Returns true if the value is a Int16Array */
+function IsInt16Array(value) {
+    return value instanceof globalThis.Int16Array;
+}
+/** Returns true if the value is a Uint16Array */
+function IsUint16Array(value) {
+    return value instanceof globalThis.Uint16Array;
+}
+/** Returns true if the value is a Int32Array */
+function IsInt32Array(value) {
+    return value instanceof globalThis.Int32Array;
+}
+/** Returns true if the value is a Uint32Array */
+function IsUint32Array(value) {
+    return value instanceof globalThis.Uint32Array;
+}
+/** Returns true if the value is a Float32Array */
+function IsFloat32Array(value) {
+    return value instanceof globalThis.Float32Array;
+}
+/** Returns true if the value is a Float64Array */
+function IsFloat64Array(value) {
+    return value instanceof globalThis.Float64Array;
+}
+/** Returns true if the value is a BigInt64Array */
+function IsBigInt64Array(value) {
+    return value instanceof globalThis.BigInt64Array;
+}
+/** Returns true if the value is a BigUint64Array */
+function IsBigUint64Array(value) {
+    return value instanceof globalThis.BigUint64Array;
+}
+// ------------------------------------------------------------------
+// RegExp
+// ------------------------------------------------------------------
+/** Returns true if the value is a RegExp */
+function IsRegExp(value) {
+    return value instanceof globalThis.RegExp;
+}
+// ------------------------------------------------------------------
+// Date
+// ------------------------------------------------------------------
+/** Returns true if the value is a Date */
+function IsDate(value) {
+    return value instanceof globalThis.Date;
+}
+// ------------------------------------------------------------------
+// Set
+// ------------------------------------------------------------------
+/** Returns true if the value is a Set */
+function IsSet(value) {
+    return value instanceof globalThis.Set;
+}
+// ------------------------------------------------------------------
+// Map
+// ------------------------------------------------------------------
+/** Returns true if the value is a Map */
+function IsMap(value) {
+    return value instanceof globalThis.Map;
+}

package/build/cjs/guard/guard.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsArray = IsArray;
+exports.IsAsyncIterator = IsAsyncIterator;
+exports.IsBigInt = IsBigInt;
+exports.IsBoolean = IsBoolean;
+exports.IsConstructor = IsConstructor;
+exports.IsFunction = IsFunction;
+exports.IsInteger = IsInteger;
+exports.IsIterator = IsIterator;
+exports.IsNull = IsNull;
+exports.IsNumber = IsNumber;
+exports.IsObjectNotArray = IsObjectNotArray;
+exports.IsObject = IsObject;
+exports.IsString = IsString;
+exports.IsSymbol = IsSymbol;
+exports.IsUndefined = IsUndefined;
+exports.IsEqual = IsEqual;
+exports.IsGreaterThan = IsGreaterThan;
+exports.IsLessThan = IsLessThan;
+exports.IsLessEqualThan = IsLessEqualThan;
+exports.IsGreaterEqualThan = IsGreaterEqualThan;
+exports.IsMultipleOf = IsMultipleOf;
+exports.IsClassInstance = IsClassInstance;
+exports.IsValueLike = IsValueLike;
+exports.StringGraphemeCount = StringGraphemeCount;
+exports.Every = Every;
+exports.EveryAll = EveryAll;
+exports.HasPropertyKey = HasPropertyKey;
+exports.EntriesRegExp = EntriesRegExp;
+exports.Entries = Entries;
+exports.Keys = Keys;
+exports.Symbols = Symbols;
+exports.Values = Values;
+exports.IsDeepEqual = IsDeepEqual;
+// --------------------------------------------------------------------------
+// Guards
+// --------------------------------------------------------------------------
+/** Returns true if this value is an array */
+function IsArray(value) {
+    return Array.isArray(value);
+}
+/** Returns true if this value is an async iterator */
+function IsAsyncIterator(value) {
+    return IsObject(value) && Symbol.asyncIterator in value;
+}
+/** Returns true if this value is bigint */
+function IsBigInt(value) {
+    return IsEqual(typeof value, 'bigint');
+}
+/** Returns true if this value is a boolean */
+function IsBoolean(value) {
+    return IsEqual(typeof value, 'boolean');
+}
+/** Returns true if this value is a constructor */
+function IsConstructor(value) {
+    if (IsUndefined(value) || !IsFunction(value))
+        return false;
+    const result = Function.prototype.toString.call(value);
+    if (/^class\s/.test(result))
+        return true;
+    if (/\[native code\]/.test(result))
+        return true;
+    return false;
+}
+/** Returns true if this value is a function */
+function IsFunction(value) {
+    return IsEqual(typeof value, 'function');
+}
+/** Returns true if this value is integer */
+function IsInteger(value) {
+    return Number.isInteger(value);
+}
+/** Returns true if this value is an iterator */
+function IsIterator(value) {
+    return IsObject(value) && Symbol.iterator in value;
+}
+/** Returns true if this value is null */
+function IsNull(value) {
+    return IsEqual(value, null);
+}
+/** Returns true if this value is number */
+function IsNumber(value) {
+    return Number.isFinite(value);
+}
+/** Returns true if this value is an object but not an array */
+function IsObjectNotArray(value) {
+    return IsObject(value) && !IsArray(value);
+}
+/** Returns true if this value is an object */
+function IsObject(value) {
+    return IsEqual(typeof value, 'object') && !(IsNull(value));
+}
+/** Returns true if this value is string */
+function IsString(value) {
+    return IsEqual(typeof value, 'string');
+}
+/** Returns true if this value is symbol */
+function IsSymbol(value) {
+    return IsEqual(typeof value, 'symbol');
+}
+/** Returns true if this value is undefined */
+function IsUndefined(value) {
+    return IsEqual(value, undefined);
+}
+// --------------------------------------------------------------------------
+// Relational
+// --------------------------------------------------------------------------
+function IsEqual(left, right) {
+    return left === right;
+}
+function IsGreaterThan(left, right) {
+    return left > right;
+}
+function IsLessThan(left, right) {
+    return left < right;
+}
+function IsLessEqualThan(left, right) {
+    return left <= right;
+}
+function IsGreaterEqualThan(left, right) {
+    return left >= right;
+}
+// --------------------------------------------------------------------------
+// MultipleOf
+// --------------------------------------------------------------------------
+function IsMultipleOf(dividend, divisor) {
+    if (IsBigInt(dividend) || IsBigInt(divisor)) {
+        return BigInt(dividend) % BigInt(divisor) === 0n;
+    }
+    const tolerance = 1e-10;
+    if (!IsNumber(dividend))
+        return true;
+    if (IsInteger(dividend) && (1 / divisor) % 1 === 0)
+        return true;
+    const mod = dividend % divisor;
+    return Math.min(Math.abs(mod), Math.abs(mod - divisor)) < tolerance;
+}
+// ------------------------------------------------------------------
+// IsClassInstance
+// ------------------------------------------------------------------
+/** Returns true if the value appears to be an instance of a class. */
+function IsClassInstance(value) {
+    if (!IsObject(value))
+        return false;
+    const proto = globalThis.Object.getPrototypeOf(value);
+    if (IsNull(proto))
+        return false;
+    return IsEqual(typeof proto.constructor, 'function') &&
+        !(IsEqual(proto.constructor, globalThis.Object) ||
+            IsEqual(proto.constructor.name, 'Object'));
+}
+// ------------------------------------------------------------------
+// IsValueLike
+// ------------------------------------------------------------------
+function IsValueLike(value) {
+    return IsBigInt(value) ||
+        IsBoolean(value) ||
+        IsNull(value) ||
+        IsNumber(value) ||
+        IsString(value) ||
+        IsUndefined(value);
+}
+// --------------------------------------------------------------------------
+// String
+// --------------------------------------------------------------------------
+/** Returns the number of Unicode Grapheme Clusters */
+function StringGraphemeCount(value) {
+    return Array.from(value).length;
+}
+// --------------------------------------------------------------------------
+// Array
+// --------------------------------------------------------------------------
+function Every(value, offset, callback) {
+    for (let index = offset; index < value.length; index++) {
+        if (!callback(value[index], index))
+            return false;
+    }
+    return true;
+}
+function EveryAll(value, offset, callback) {
+    let result = true;
+    for (let index = offset; index < value.length; index++) {
+        if (!callback(value[index], index))
+            result = false;
+    }
+    return result;
+}
+// --------------------------------------------------------------------------
+// Object
+// --------------------------------------------------------------------------
+/** Returns true if this value has this property key */
+function HasPropertyKey(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+/** Returns object entries as `[RegExp, Value][]` */
+function EntriesRegExp(value) {
+    return Keys(value).map((key) => [new RegExp(`^${key}$`), value[key]]);
+}
+/** Returns object entries as `[string, Value][]` */
+function Entries(value) {
+    return Object.entries(value);
+}
+/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+function Keys(value) {
+    return Object.getOwnPropertyNames(value);
+}
+/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+function Symbols(value) {
+    return Object.getOwnPropertySymbols(value);
+}
+/** Returns the property values for the given object via `Object.values()` */
+function Values(value) {
+    return Object.values(value);
+}
+// ------------------------------------------------------------------
+// IsDeepEqual
+// ------------------------------------------------------------------
+function DeepEqualObject(left, right) {
+    if (!IsObject(right))
+        return false;
+    const keys = Keys(left);
+    return IsEqual(keys.length, Keys(right).length) &&
+        keys.every((key) => IsDeepEqual(left[key], right[key]));
+}
+function DeepEqualArray(left, right) {
+    return IsArray(right) && IsEqual(left.length, right.length) &&
+        left.every((_, index) => IsDeepEqual(left[index], right[index]));
+}
+/** Tests values for deep equality */
+function IsDeepEqual(left, right) {
+    return (IsArray(left) ? DeepEqualArray(left, right) : IsObject(left) ? DeepEqualObject(left, right) : IsEqual(left, right));
+}

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

@@ -0,0 +1,6 @@
+export * as EmitGuard from './emit';
+export * as GlobalsGuard from './globals';
+export * as NativeGuard from './native';
+import * as Guard from './guard';
+export * as Guard from './guard';
+export default Guard;

package/build/cjs/guard/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Guard = exports.NativeGuard = exports.GlobalsGuard = exports.EmitGuard = void 0;
+exports.EmitGuard = require("./emit");
+exports.GlobalsGuard = require("./globals");
+exports.NativeGuard = require("./native");
+const Guard = require("./guard");
+exports.Guard = require("./guard");
+exports.default = Guard;

package/build/cjs/guard/native.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsF32 = IsF32;
+exports.IsF64 = IsF64;
+exports.IsU8 = IsU8;
+exports.IsU16 = IsU16;
+exports.IsU32 = IsU32;
+exports.IsU64 = IsU64;
+exports.IsI8 = IsI8;
+exports.IsI16 = IsI16;
+exports.IsI32 = IsI32;
+exports.IsI64 = IsI64;
+const Guard = require("./guard");
+// --------------------------------------------------------------------------
+// Native
+// --------------------------------------------------------------------------
+/** Returns true if this value is a F32 */
+function IsF32(value) {
+    return Guard.IsNumber(value) &&
+        Guard.IsEqual(value, Math.fround(value));
+}
+/** Returns true if this value is a F64 */
+function IsF64(value) {
+    return Guard.IsNumber(value);
+}
+/** Returns true if this value is a U8 */
+function IsU8(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, 0) &&
+        Guard.IsLessEqualThan(value, 255);
+}
+/** Returns true if this value is a U16 */
+function IsU16(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, 0) &&
+        Guard.IsLessEqualThan(value, 65535);
+}
+/** Returns true if this value is a U32 */
+function IsU32(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, 0) &&
+        Guard.IsLessEqualThan(value, 4294967295);
+}
+/** Returns true if this value is a U64 */
+function IsU64(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, 0);
+}
+/** Returns true if this value is a I8 */
+function IsI8(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, -128) &&
+        Guard.IsLessEqualThan(value, 127);
+}
+/** Returns true if this value is a I16 */
+function IsI16(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, -32768) &&
+        Guard.IsLessEqualThan(value, 32767);
+}
+/** Returns true if this value is a I32 */
+function IsI32(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, -2147483648) &&
+        Guard.IsLessEqualThan(value, 2147483647);
+}
+/** Returns true if this value is a I64 */
+function IsI64(value) {
+    return Guard.IsBigInt(value) &&
+        Guard.IsGreaterEqualThan(value, BigInt('-9223372036854775808')) &&
+        Guard.IsLessEqualThan(value, BigInt('9223372036854775807'));
+}

package/build/cjs/index.d.ts

@@ -0,0 +1,8 @@
+export * from './type/action/index';
+export * from './type/engine/index';
+export * from './type/extends/index';
+export * from './type/script/index';
+export * from './type/types/index';
+export * as Type from './typebox';
+import * as Type from './typebox';
+export default Type;

package/build/cjs/index.js

@@ -0,0 +1,31 @@
+"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.Type = void 0;
+// ------------------------------------------------------------------
+// Standard
+// ------------------------------------------------------------------
+__exportStar(require("./type/action/index"), exports);
+__exportStar(require("./type/engine/index"), exports);
+__exportStar(require("./type/extends/index"), exports);
+__exportStar(require("./type/script/index"), exports);
+__exportStar(require("./type/types/index"), exports);
+// ------------------------------------------------------------------
+// TypeBox
+// ------------------------------------------------------------------
+exports.Type = require("./typebox");
+const Type = require("./typebox");
+exports.default = Type;

package/build/cjs/schema/build.d.ts

@@ -0,0 +1,35 @@
+import * as Engine from './engine/index';
+import { type XSchemaLike } from './types/index';
+export type CheckFunction = (value: unknown) => boolean;
+export interface EvaluateResult {
+    IsEvaluated: boolean;
+    Code: string;
+    Check: CheckFunction;
+}
+export declare class BuildResult {
+    private readonly context;
+    private readonly schema;
+    private readonly external;
+    private readonly functions;
+    private readonly call;
+    private readonly useUnevaluated;
+    constructor(context: Record<PropertyKey, XSchemaLike>, schema: XSchemaLike, external: Engine.TExternal, functions: string[], call: string, useUnevaluated: boolean);
+    /** Returns the Context used for this build */
+    Context(): Record<PropertyKey, XSchemaLike>;
+    /** Returns the Schema used for this build */
+    Schema(): XSchemaLike;
+    /** Returns true if this build requires a Unevaluated context */
+    UseUnevaluated(): boolean;
+    /** Returns external variables */
+    External(): Engine.TExternal;
+    /** Returns check functions */
+    Functions(): string[];
+    /** Return entry function call. */
+    Call(): string;
+    /** Evaluates the build into a validation function */
+    Evaluate(): EvaluateResult;
+}
+/** Builds a schema into a optimized runtime validator */
+export declare function Build(schema: XSchemaLike): BuildResult;
+/** Builds a schema into a optimized runtime validator */
+export declare function Build(context: Record<PropertyKey, XSchemaLike>, schema: XSchemaLike): BuildResult;

package/build/cjs/schema/build.js

@@ -0,0 +1,102 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildResult = void 0;
+exports.Build = Build;
+const index_1 = require("../system/arguments/index");
+const index_2 = require("../system/environment/index");
+const index_3 = require("../system/hashing/index");
+const index_4 = require("../guard/index");
+const index_5 = require("../format/index");
+const Engine = require("./engine/index");
+// ------------------------------------------------------------------
+// CreateCode
+// ------------------------------------------------------------------
+function CreateCode(build) {
+    const functions = build.Functions().join(';\n');
+    const statements = build.UseUnevaluated()
+        ? ['const context = new CheckContext({}, {})', `return ${build.Call()}`]
+        : [`return ${build.Call()}`];
+    return `${functions}; return (value) => { ${statements.join('; ')} }`;
+}
+// ------------------------------------------------------------------
+// CreateEvaluatedCheck
+// ------------------------------------------------------------------
+function CreateEvaluatedCheck(build, code) {
+    const factory = new globalThis.Function('CheckContext', 'Guard', 'Format', 'Hashing', build.External().identifier, code);
+    return factory(Engine.CheckContext, index_4.Guard, index_5.Format, index_3.Hashing, build.External().variables);
+}
+// ------------------------------------------------------------------
+// CreateDynamicCheck
+// ------------------------------------------------------------------
+function CreateDynamicCheck(build) {
+    const context = new Engine.CheckContext(build.Context(), build.Schema());
+    return (value) => Engine.CheckSchema(context, build.Schema(), value);
+}
+// ------------------------------------------------------------------
+// CreateCheck
+// ------------------------------------------------------------------
+function CreateCheck(build, code) {
+    return index_2.Environment.CanEvaluate()
+        ? CreateEvaluatedCheck(build, code)
+        : CreateDynamicCheck(build);
+}
+// ------------------------------------------------------------------
+// BuildResult
+// ------------------------------------------------------------------
+class BuildResult {
+    constructor(context, schema, external, functions, call, useUnevaluated) {
+        this.context = context;
+        this.schema = schema;
+        this.external = external;
+        this.functions = functions;
+        this.call = call;
+        this.useUnevaluated = useUnevaluated;
+    }
+    /** Returns the Context used for this build */
+    Context() {
+        return this.context;
+    }
+    /** Returns the Schema used for this build */
+    Schema() {
+        return this.schema;
+    }
+    /** Returns true if this build requires a Unevaluated context */
+    UseUnevaluated() {
+        return this.useUnevaluated;
+    }
+    /** Returns external variables */
+    External() {
+        return this.external;
+    }
+    /** Returns check functions */
+    Functions() {
+        return this.functions;
+    }
+    /** Return entry function call. */
+    Call() {
+        return this.call;
+    }
+    /** Evaluates the build into a validation function */
+    Evaluate() {
+        const Code = CreateCode(this);
+        const Check = CreateCheck(this, Code);
+        return { IsEvaluated: index_2.Environment.CanEvaluate(), Code, Check };
+    }
+}
+exports.BuildResult = BuildResult;
+/** Builds a schema into a optimized runtime validator */
+function Build(...args) {
+    const [context, schema] = index_1.Arguments.Match(args, {
+        2: (context, schema) => [context, schema],
+        1: (schema) => [{}, schema]
+    });
+    Engine.ResetExternal();
+    Engine.ResetFunctions();
+    const build = new Engine.BuildContext(context, schema, Engine.HasUnevaluated(context, schema));
+    const call = Engine.CreateFunction(build, schema, 'value');
+    const functions = Engine.GetFunctions();
+    const externals = Engine.GetExternal();
+    return new BuildResult(context, schema, externals, functions, call, build.UseUnevaluated());
+}

package/build/cjs/schema/check.d.ts

@@ -0,0 +1,5 @@
+import { XSchemaLike } from './types/index';
+/** Checks a value against the provided schema */
+export declare function Check(schema: XSchemaLike, value: unknown): boolean;
+/** Checks a value against the provided schema */
+export declare function Check(context: Record<PropertyKey, XSchemaLike>, schema: XSchemaLike, value: unknown): boolean;

package/build/cjs/schema/check.js

@@ -0,0 +1,15 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Check = Check;
+const index_1 = require("../system/arguments/index");
+const index_2 = require("./engine/index");
+/** Checks a value against the provided schema */
+function Check(...args) {
+    const [context, schema, value] = index_1.Arguments.Match(args, {
+        3: (context, schema, value) => [context, schema, value],
+        2: (schema, value) => [{}, schema, value]
+    });
+    return (0, index_2.CheckSchema)(new index_2.CheckContext(context, schema), schema, value);
+}

package/build/cjs/schema/deref/deref.d.ts

@@ -0,0 +1,4 @@
+import * as S from '../types/index';
+export declare function Rebase(baseUri: string, schema: S.XSchema): string;
+/** Deferences a schema with the given Ref */
+export declare function Deref(schema: object, ref: S.XRef): unknown | undefined;