typebox 0.0.1 → 1.0.0-rc

package/build/compile/code.d.mts

@@ -0,0 +1,12 @@
+import { type TProperties, type TSchema } from '../type/index.mjs';
+import { type TExternal } from '../schema/index.mjs';
+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/compile/code.mjs

@@ -0,0 +1,65 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { Build } from '../schema/index.mjs';
+// ------------------------------------------------------------------
+// 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. */
+export function Code(...args) {
+    const [context, type] = Arguments.Match(args, {
+        2: (context, type) => [context, type],
+        1: (type) => [{}, type]
+    });
+    const build = Build(context, type);
+    const code = [...ImportSection(build), ...ExternalSection(build), ...FunctionSection(build), ...ExportSection(build)].join('\n');
+    return { External: build.External(), Code: code };
+}

package/build/compile/compile.d.mts

@@ -0,0 +1,6 @@
+import { type TProperties, type TSchema } from '../type/index.mjs';
+import { Validator } from './validator.mjs';
+/** 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/compile/compile.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { Validator } from './validator.mjs';
+/** Compiles a type into a high performance Validator */
+export function Compile(...args) {
+    const [context, type] = Arguments.Match(args, {
+        2: (context, type) => [context, type],
+        1: (type) => [{}, type]
+    });
+    return new Validator(context, type);
+}

package/build/compile/index.d.mts

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

package/build/compile/index.mjs

@@ -0,0 +1,13 @@
+// ------------------------------------------------------------------
+// Barrel
+// ------------------------------------------------------------------
+export * from './code.mjs';
+export * from './compile.mjs';
+export * from './validator.mjs';
+// ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
+import { Code } from './code.mjs';
+import { Compile } from './compile.mjs';
+import { Validator } from './validator.mjs';
+export default { Code, Compile, Validator };

package/build/compile/validator.d.mts

@@ -0,0 +1,30 @@
+import { type TLocalizedValidationError } from '../error/index.mjs';
+import { type StaticDecode, type StaticEncode, type TProperties, type TSchema, Base } from '../type/index.mjs';
+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 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;
+    Check(value: unknown): value is StaticEncode<Type, Context>;
+    Errors(value: unknown): TLocalizedValidationError[];
+    Clean(value: unknown): unknown;
+    Convert(value: unknown): unknown;
+    Create(): StaticEncode<Type, Context>;
+    Default(value: unknown): unknown;
+    /** Parses a value of this type */
+    Parse(value: unknown): StaticDecode<Type, Context>;
+    /** Decodes a value of this type */
+    Decode(value: unknown): StaticDecode<Type, Context>;
+    /** Encodes a value of this type */
+    Encode(value: unknown): StaticEncode<Type, Context>;
+}

package/build/compile/validator.mjs

@@ -0,0 +1,83 @@
+// deno-fmt-ignore-file
+import { Environment } from '../system/environment/index.mjs';
+import { Base } from '../type/index.mjs';
+import { Errors, Clean, Convert, Create, Default, Parser, Decode, Encode } from '../value/index.mjs';
+import { Build } from '../schema/index.mjs';
+// ------------------------------------------------------------------
+// ValidatorType<...>
+// ------------------------------------------------------------------
+export class Validator extends Base {
+    constructor(context, type) {
+        super();
+        this.context = context;
+        this.type = type;
+        const result = Build(context, type).Evaluate();
+        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<...>
+    // ----------------------------------------------------------------
+    Check(value) {
+        return this.check(value);
+    }
+    Errors(value) {
+        if (Environment.CanEvaluate() && this.check(value))
+            return [];
+        return Errors(this.context, this.type, value);
+    }
+    Clean(value) {
+        return Clean(this.context, this.type, value);
+    }
+    Convert(value) {
+        return Convert(this.context, this.type, value);
+    }
+    Create() {
+        return Create(this.context, this.type);
+    }
+    Default(value) {
+        return Default(this.context, this.type, value);
+    }
+    // ----------------------------------------------------------------
+    // Parse
+    // ----------------------------------------------------------------
+    /** Parses a value of this type */
+    Parse(value) {
+        const result = this.Check(value) ? value : Parser(this.context, this.type, value);
+        return result;
+    }
+    /** Decodes a value of this type */
+    Decode(value) {
+        return Decode(this.context, this.type, value);
+    }
+    /** Encodes a value of this type */
+    Encode(value) {
+        return Encode(this.context, this.type, value);
+    }
+}

package/build/error/errors.d.mts

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

package/build/error/errors.mjs

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

package/build/error/index.d.mts

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

package/build/error/index.mjs

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

package/build/format/_registry.d.mts

@@ -0,0 +1,15 @@
+export type TFormatCheckFunction = (value: string) => boolean;
+/** Clears all entries */
+export declare function Clear(): void;
+/** Returns format entries in this registry */
+export declare function Entries(): [string, TFormatCheckFunction][];
+/** Sets a format */
+export declare function Set(format: string, check: TFormatCheckFunction): void;
+/** Returns true if the registry has this format */
+export declare function Has(format: string): boolean;
+/** Gets a format or undefined if not exists */
+export declare function Get(format: string): TFormatCheckFunction | undefined;
+/** Tests a value against a format, if the format is not registered, true */
+export declare function Test(format: string, value: string): boolean;
+/** Resets all formats to defaults */
+export declare function Reset(): void;

package/build/format/_registry.mjs

@@ -0,0 +1,96 @@
+import { IsDateTime } from './date-time.mjs';
+import { IsDate } from './date.mjs';
+import { IsDuration } from './duration.mjs';
+import { IsEmail } from './email.mjs';
+import { IsHostname } from './hostname.mjs';
+import { IsIdnEmail } from './idn-email.mjs';
+import { IsIdnHostname } from './idn-hostname.mjs';
+import { IsIPv4 } from './ipv4.mjs';
+import { IsIPv6 } from './ipv6.mjs';
+import { IsIriReference } from './iri-reference.mjs';
+import { IsIri } from './iri.mjs';
+import { IsJsonPointerUriFragment } from './json-pointer-uri-fragment.mjs';
+import { IsJsonPointer } from './json-pointer.mjs';
+import { IsRegex } from './regex.mjs';
+import { IsRelativeJsonPointer } from './relative-json-pointer.mjs';
+import { IsTime } from './time.mjs';
+import { IsUriReference } from './uri-reference.mjs';
+import { IsUriTemplate } from './uri-template.mjs';
+import { IsUri } from './uri.mjs';
+import { IsUrl } from './url.mjs';
+import { IsUuid } from './uuid.mjs';
+// ------------------------------------------------------------------
+// Formats
+// ------------------------------------------------------------------
+const formats = new Map();
+// ------------------------------------------------------------------
+// Clear
+// ------------------------------------------------------------------
+/** Clears all entries */
+export function Clear() {
+    formats.clear();
+}
+// ------------------------------------------------------------------
+// Entries
+// ------------------------------------------------------------------
+/** Returns format entries in this registry */
+export function Entries() {
+    return [...formats.entries()];
+}
+// ------------------------------------------------------------------
+// Set
+// ------------------------------------------------------------------
+/** Sets a format */
+export function Set(format, check) {
+    formats.set(format, check);
+}
+// ------------------------------------------------------------------
+// Has
+// ------------------------------------------------------------------
+/** Returns true if the registry has this format */
+export function Has(format) {
+    return formats.has(format);
+}
+// ------------------------------------------------------------------
+// Get
+// ------------------------------------------------------------------
+/** Gets a format or undefined if not exists */
+export function Get(format) {
+    return formats.get(format);
+}
+// ------------------------------------------------------------------
+// Test
+// ------------------------------------------------------------------
+/** Tests a value against a format, if the format is not registered, true */
+export function Test(format, value) {
+    return formats.get(format)?.(value) ?? true;
+}
+// ------------------------------------------------------------------
+// Reset
+// ------------------------------------------------------------------
+/** Resets all formats to defaults */
+export function Reset() {
+    Clear();
+    formats.set('date-time', IsDateTime);
+    formats.set('date', IsDate);
+    formats.set('duration', IsDuration);
+    formats.set('email', IsEmail);
+    formats.set('hostname', IsHostname);
+    formats.set('idn-email', IsIdnEmail);
+    formats.set('idn-hostname', IsIdnHostname);
+    formats.set('ipv4', IsIPv4);
+    formats.set('ipv6', IsIPv6);
+    formats.set('iri-reference', IsIriReference);
+    formats.set('iri', IsIri);
+    formats.set('json-pointer-uri-fragment', IsJsonPointerUriFragment);
+    formats.set('json-pointer', IsJsonPointer);
+    formats.set('regex', IsRegex);
+    formats.set('relative-json-pointer', IsRelativeJsonPointer);
+    formats.set('time', IsTime);
+    formats.set('uri-reference', IsUriReference);
+    formats.set('uri-template', IsUriTemplate);
+    formats.set('uri', IsUri);
+    formats.set('url', IsUrl);
+    formats.set('uuid', IsUuid);
+}
+Reset();

package/build/format/date-time.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Returns true if the value is a ISO8601 DateTime string
+ * @source ajv-formats
+ * @example `2020-12-12T20:20:40+00:00`
+ */
+export declare function IsDateTime(value: string, strictTimeZone?: boolean): boolean;

package/build/format/date-time.mjs

@@ -0,0 +1,11 @@
+import { IsDate } from './date.mjs';
+import { IsTime } from './time.mjs';
+/**
+ * Returns true if the value is a ISO8601 DateTime string
+ * @source ajv-formats
+ * @example `2020-12-12T20:20:40+00:00`
+ */
+export function IsDateTime(value, strictTimeZone = true) {
+    const dateTime = value.split(/T/i);
+    return dateTime.length === 2 && IsDate(dateTime[0]) && IsTime(dateTime[1], strictTimeZone);
+}

package/build/format/date.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Returns true if the value is a ISO8601 Date component string
+ * @source ajv-formats
+ * @example `2020-12-12`
+ */
+export declare function IsDate(value: string): boolean;

package/build/format/date.mjs

@@ -0,0 +1,19 @@
+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`
+ */
+export 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/format/duration.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Returns true if the value is a Duration string
+ * @source ajv-formats
+ */
+export declare function IsDuration(value: string): boolean;

package/build/format/duration.mjs

@@ -0,0 +1,8 @@
+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
+ */
+export function IsDuration(value) {
+    return Duration.test(value);
+}

package/build/format/email.d.mts

@@ -0,0 +1,2 @@
+/** Returns true if the value is an Email */
+export declare function IsEmail(value: string): boolean;

package/build/format/email.mjs

@@ -0,0 +1,5 @@
+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 */
+export function IsEmail(value) {
+    return Email.test(value);
+}

package/build/format/format.d.mts

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