typebox 1.0.16 → 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,26 +1,15 @@
 import { type TSchema } from './schema.mjs';
-type TResult<Value extends unknown = unknown> = TValue<Value> | TIssues;
-interface TValue<Value extends unknown = unknown> {
-    value: Value;
-}
-interface TIssues {
-    issues: object[];
-}
-declare class StandardValidatorV1<Value extends unknown = unknown> {
-    private readonly check;
-    private readonly errors;
-    readonly vendor = "typebox";
-    readonly version = 1;
-    constructor(check: (value: unknown) => boolean, errors: (value: unknown) => object[]);
-    readonly validate: (value: unknown) => TResult<Value>;
-}
 export declare class BaseNotImplemented extends Error {
-    constructor(type: Base, override: string);
+    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': StandardValidatorV1<Value>;
+    readonly '~standard': StandardSchemaV1.Props<Value>;
     constructor();
     /** Checks a value or returns false if invalid */
     Check(value: unknown): value is Value;
@@ -37,4 +26,37 @@ export declare class Base<Value extends unknown = unknown> implements TSchema {
 }
 /** 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> {
+    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+    export interface Props<Input = unknown, Output = Input> {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    export type Result<Output> = SuccessResult<Output> | FailureResult;
+    export interface SuccessResult<Output> {
+        readonly value: Output;
+        readonly issues?: undefined;
+    }
+    export interface FailureResult {
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    export interface Issue {
+        readonly message: string;
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    export interface PathSegment {
+        readonly key: PropertyKey;
+    }
+    export interface Types<Input = unknown, Output = Input> {
+        readonly input: Input;
+        readonly output: Output;
+    }
+    export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+    export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+    export {};
+}
 export {};

package/build/type/types/base.mjs

@@ -1,47 +1,57 @@
 // deno-fmt-ignore-file
+import { IsLocalizedValidationError } from '../../error/index.mjs';
+import { Guard } from '../../guard/index.mjs';
 import { IsKind } from './schema.mjs';
-function Value(value) {
-    return { value };
-}
-function Issues(issues) {
-    return { issues };
+// ------------------------------------------------------------------
+// BaseNotImplemented
+// ------------------------------------------------------------------
+export class BaseNotImplemented extends Error {
+    constructor(type, method) {
+        super(`Base type does not implement the '${method}' function`);
+        Object.defineProperty(this, 'cause', {
+            value: { type, method },
+            writable: false,
+            configurable: false,
+            enumerable: false
+        });
+    }
 }
 // ------------------------------------------------------------------------------------
-// StandardValidatorV1
+// BaseValidator
 // ------------------------------------------------------------------------------------
-class StandardValidatorV1 {
+class BaseValidator {
     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));
+            return this.check(value)
+                ? this.Success(value)
+                : this.Failure(this.errors(value));
         };
     }
-}
-// ------------------------------------------------------------------
-// BaseError
-// ------------------------------------------------------------------
-export class BaseNotImplemented extends Error {
-    constructor(type, override) {
-        // @ts-ignore - options supported in deno, node, etc.
-        super(`Base type does not implement '${override}' function`, { cause: type });
+    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,
             enumerable: false
         };
-        Object.defineProperty(this, '~kind', { ...configuration, value: 'Base', });
+        Object.defineProperty(this, '~kind', { ...configuration, value: 'Base' });
         Object.defineProperty(this, '~standard', { ...configuration, value: validator });
     }
     /** Checks a value or returns false if invalid */
@@ -76,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.16",
+  "version": "1.0.18",
   "keywords": [
     "typescript",
     "jsonschema"