typebox 1.0.17 → 1.0.18

package/build/error/errors.d.mts

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

package/build/error/errors.mjs

@@ -1 +1,17 @@
-export {};
+import { Guard } from '../guard/index.mjs';
+export function IsValidationError(value) {
+    return Guard.IsObject(value) &&
+        Guard.HasPropertyKey(value, 'keyword') &&
+        Guard.HasPropertyKey(value, 'schemaPath') &&
+        Guard.HasPropertyKey(value, 'instancePath') &&
+        Guard.HasPropertyKey(value, 'params') &&
+        Guard.IsString(value.keyword) &&
+        Guard.IsString(value.schemaPath) &&
+        Guard.IsString(value.instancePath) &&
+        Guard.IsObject(value.params);
+}
+export function IsLocalizedValidationError(value) {
+    return IsValidationError(value) &&
+        Guard.HasPropertyKey(value, 'message') &&
+        Guard.IsString(value.message);
+}

package/build/type/types/base.d.mts

@@ -1,84 +1,62 @@
 import { type TSchema } from './schema.mjs';
+export declare class BaseNotImplemented extends Error {
+    readonly cause: {
+        type: Base;
+        method: string;
+    };
+    constructor(type: Base, method: string);
+}
+/** Base class for creating extension types. */
+export declare class Base<Value extends unknown = unknown> implements TSchema {
+    readonly '~kind': 'Base';
+    readonly '~standard': StandardSchemaV1.Props<Value>;
+    constructor();
+    /** Checks a value or returns false if invalid */
+    Check(value: unknown): value is Value;
+    /** Returns errors for a value. Return an empty array if valid.  */
+    Errors(value: unknown): object[];
+    /** Converts a value into this type */
+    Convert(value: unknown): unknown;
+    /** Cleans a value according to this type */
+    Clean(value: unknown): unknown;
+    /** Returns a default value for this type */
+    Default(value: unknown): unknown;
+    /** Creates a new instance of this type */
+    Create(): Value;
+}
+/** Returns true if the given value is a Base type. */
+export declare function IsBase(value: unknown): value is Base;
 interface StandardSchemaV1<Input = unknown, Output = Input> {
-    /** The Standard Schema properties. */
     readonly '~standard': StandardSchemaV1.Props<Input, Output>;
 }
 declare namespace StandardSchemaV1 {
-    /** The Standard Schema properties interface. */
     export interface Props<Input = unknown, Output = Input> {
-        /** The version number of the standard. */
         readonly version: 1;
-        /** The vendor name of the schema library. */
         readonly vendor: string;
-        /** Validates unknown input values. */
         readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-        /** Inferred types associated with the schema. */
         readonly types?: Types<Input, Output> | undefined;
     }
-    /** The result interface of the validate function. */
     export type Result<Output> = SuccessResult<Output> | FailureResult;
-    /** The result interface if validation succeeds. */
     export interface SuccessResult<Output> {
-        /** The typed output value. */
         readonly value: Output;
-        /** The non-existent issues. */
         readonly issues?: undefined;
     }
-    /** The result interface if validation fails. */
     export interface FailureResult {
-        /** The issues of failed validation. */
         readonly issues: ReadonlyArray<Issue>;
     }
-    /** The issue interface of the failure output. */
     export interface Issue {
-        /** The error message of the issue. */
         readonly message: string;
-        /** The path of the issue, if any. */
         readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
     }
-    /** The path segment interface of the issue. */
     export interface PathSegment {
-        /** The key representing a path segment. */
         readonly key: PropertyKey;
     }
-    /** The Standard Schema types interface. */
     export interface Types<Input = unknown, Output = Input> {
-        /** The input type of the schema. */
         readonly input: Input;
-        /** The output type of the schema. */
         readonly output: Output;
     }
-    /** Infers the input type of a Standard Schema. */
     export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
-    /** Infers the output type of a Standard Schema. */
     export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
     export {};
 }
-export declare class BaseNotImplemented extends Error {
-    readonly cause: {
-        type: Base;
-        method: string;
-    };
-    constructor(type: Base, method: string);
-}
-/** Base class for creating extension types. */
-export declare class Base<Value extends unknown = unknown> implements TSchema {
-    readonly '~kind': 'Base';
-    readonly '~standard': StandardSchemaV1.Props<Value>;
-    constructor();
-    /** Checks a value or returns false if invalid */
-    Check(value: unknown): value is Value;
-    /** Returns errors for a value. Return an empty array if valid.  */
-    Errors(value: unknown): object[];
-    /** Converts a value into this type */
-    Convert(value: unknown): unknown;
-    /** Cleans a value according to this type */
-    Clean(value: unknown): unknown;
-    /** Returns a default value for this type */
-    Default(value: unknown): unknown;
-    /** Creates a new instance of this type */
-    Create(): Value;
-}
-/** Returns true if the given value is a Base type. */
-export declare function IsBase(value: unknown): value is Base;
 export {};

package/build/type/types/base.mjs

@@ -1,34 +1,9 @@
 // deno-fmt-ignore-file
+import { IsLocalizedValidationError } from '../../error/index.mjs';
+import { Guard } from '../../guard/index.mjs';
 import { IsKind } from './schema.mjs';
-// --------------------------------------------------------
-// Standard Schema Factory
-// --------------------------------------------------------
-function Value(value) {
-    return { value };
-}
-function Issues(issues) {
-    // We cannot guarantee that the caller will pass an object with an
-    // error message, but it is generally implied. Additionally, we do
-    // not want StandardSchema interfaces proliferating throughout the
-    // codebase; they must remain contained within this module only.
-    return { issues };
-}
-// ------------------------------------------------------------------------------------
-// StandardValidatorV1
-// ------------------------------------------------------------------------------------
-class StandardValidatorV1 {
-    constructor(check, errors) {
-        this.check = check;
-        this.errors = errors;
-        this.vendor = 'typebox';
-        this.version = 1;
-        this.validate = (value) => {
-            return (this.check(value)) ? Value(value) : Issues(this.errors(value));
-        };
-    }
-}
 // ------------------------------------------------------------------
-// BaseError
+// BaseNotImplemented
 // ------------------------------------------------------------------
 export class BaseNotImplemented extends Error {
     constructor(type, method) {
@@ -41,13 +16,36 @@ export class BaseNotImplemented extends Error {
         });
     }
 }
+// ------------------------------------------------------------------------------------
+// BaseValidator
+// ------------------------------------------------------------------------------------
+class BaseValidator {
+    constructor(check, errors) {
+        this.check = check;
+        this.errors = errors;
+        this.vendor = 'typebox';
+        this.version = 1;
+        this.validate = (value) => {
+            return this.check(value)
+                ? this.Success(value)
+                : this.Failure(this.errors(value));
+        };
+    }
+    Success(value) {
+        return { value };
+    }
+    Failure(errors) {
+        const issues = errors.reduce((result, error) => [...result, ...CreateIssues(error)], []);
+        return { issues };
+    }
+}
 // ------------------------------------------------------------------
-// Base
+// Type
 // ------------------------------------------------------------------
 /** Base class for creating extension types. */
 export class Base {
     constructor() {
-        const validator = new StandardValidatorV1((value) => this.Check(value), (value) => this.Errors(value));
+        const validator = new BaseValidator((value) => this.Check(value), (value) => this.Errors(value));
         const configuration = {
             writable: false,
             configurable: false,
@@ -88,3 +86,54 @@ export class Base {
 export function IsBase(value) {
     return IsKind(value, 'Base');
 }
+// --------------------------------------------------------
+// StandardSchema: PathSegments
+// --------------------------------------------------------
+function PathSegments(pointer) {
+    if (Guard.IsEqual(pointer.length, 0))
+        return [];
+    return pointer.slice(1).split("/").map(segment => segment.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+// --------------------------------------------------------
+// IsStandardSchemaV1Error
+// --------------------------------------------------------
+function IsStandardSchemaV1Error(error) {
+    return Guard.IsEqual(error.keyword, '~standard');
+}
+// --------------------------------------------------------
+// IssuesFromLocalizedError
+// --------------------------------------------------------
+function IssuesFromStandardSchemaV1Error(error) {
+    const leading = PathSegments(error.instancePath);
+    const issues = Guard.IsArray(error.params.issues) ? error.params.issues : [];
+    return issues.map(issue => {
+        const message = Guard.IsString(issue.message) ? issue.message : 'unknown';
+        const path = Guard.IsArray(issue.path) ? [...leading, ...issue.path] : leading;
+        return { message, path };
+    });
+}
+function IssuesFromRegularError(error) {
+    const path = PathSegments(error.instancePath);
+    return [{ path, message: error.message }];
+}
+function IssuesFromLocalizedError(error) {
+    return IsStandardSchemaV1Error(error)
+        ? IssuesFromStandardSchemaV1Error(error)
+        : IssuesFromRegularError(error);
+}
+// --------------------------------------------------------
+// IssuesFromUnknown
+// --------------------------------------------------------
+function IssuesFromUnknown(error) {
+    const path = Guard.HasPropertyKey(error, 'path') && Guard.IsArray(error.path) && error.path.every(segment => Guard.IsString(segment)) ? error.path : [];
+    const message = Guard.HasPropertyKey(error, 'message') && Guard.IsString(error.message) ? error.message : 'unknown';
+    return [{ path, message }];
+}
+// --------------------------------------------------------
+// CreateIssues
+// --------------------------------------------------------
+function CreateIssues(error) {
+    return IsLocalizedValidationError(error)
+        ? IssuesFromLocalizedError(error)
+        : IssuesFromUnknown(error);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "A Runtime Type System for JavaScript",
-  "version": "1.0.17",
+  "version": "1.0.18",
   "keywords": [
     "typescript",
     "jsonschema"