typedriver 0.8.7 → 0.8.8

package/build/errors/error-to-issue.d.mts

@@ -1,3 +1,3 @@
-import { StandardSchemaV1 } from '../_standard/standard-schema.mjs';
-import { TLocalizedValidationError } from 'typebox/error';
-export declare function errorToIssue(error: TLocalizedValidationError): StandardSchemaV1.Issue;
+import type { TJsonSchemaError, TStandardSchemaError } from '../validator.mjs';
+/** (Internal) Transform TJsonSchemaError to TStandardSchemaError */
+export declare function errorToIssue(error: TJsonSchemaError): TStandardSchemaError;

package/build/errors/error-to-issue.mjs

@@ -8,6 +8,7 @@ function pathSegments(pointer) {
         return [];
     return pointer.slice(1).split('/').map((segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~'));
 }
+/** (Internal) Transform TJsonSchemaError to TStandardSchemaError */
 export function errorToIssue(error) {
     const path = pathSegments(error.instancePath);
     return { path, message: error.message };

package/build/errors/exceptions.mjs

@@ -1,4 +1,7 @@
 // deno-fmt-ignore-file
+// ------------------------------------------------------------------
+// ParseError
+// ------------------------------------------------------------------
 export class ParseError extends globalThis.Error {
     constructor(value, errors) {
         super('ParseError');
@@ -12,6 +15,9 @@ export class ParseError extends globalThis.Error {
         });
     }
 }
+// ------------------------------------------------------------------
+// UnknownError
+// ------------------------------------------------------------------
 export class UnknownError extends globalThis.Error {
     constructor(message) {
         super(`UnknownError: ${message}`);

package/build/errors/index.d.mts

@@ -1,3 +1,5 @@
 export * from './exceptions.mjs';
 export * from './error-to-issue.mjs';
 export * from './issue-to-error.mjs';
+export * from './normal-error.mjs';
+export * from './normal-issue.mjs';

package/build/errors/index.mjs

@@ -2,3 +2,5 @@
 export * from './exceptions.mjs';
 export * from './error-to-issue.mjs';
 export * from './issue-to-error.mjs';
+export * from './normal-error.mjs';
+export * from './normal-issue.mjs';

package/build/errors/issue-to-error.d.mts

@@ -1,3 +1,3 @@
-import { StandardSchemaV1 } from '../_standard/standard-schema.mjs';
-import { TLocalizedValidationError } from 'typebox/error';
-export declare function issueToError(issue: StandardSchemaV1.Issue): TLocalizedValidationError;
+import type { TStandardSchemaError, TJsonSchemaError } from '../validator.mjs';
+/** (Internal) Transform TStandardSchemaError to TJsonSchemaError */
+export declare function issueToError(issue: TStandardSchemaError): TJsonSchemaError;

package/build/errors/issue-to-error.mjs

@@ -1,15 +1,23 @@
 // deno-fmt-ignore-file
-import { Guard } from 'typebox/guard';
 // ------------------------------------------------------------------
-// Issues
+// Escape
 // ------------------------------------------------------------------
-function jsonPointer(segments) {
-    return `#${segments.join('/')}`;
+function escapeKey(segment) {
+    return `${segment}`.replace(/~/g, '~0').replace(/\//g, '~1');
 }
+// ------------------------------------------------------------------
+// Json Pointer
+// ------------------------------------------------------------------
+function pathToJsonPointer(path) {
+    const keys = path.map(escapeKey);
+    return `#/${keys.join('/')}`;
+}
+// ------------------------------------------------------------------
+// IssueToError
+// ------------------------------------------------------------------
+/** (Internal) Transform TStandardSchemaError to TJsonSchemaError */
 export function issueToError(issue) {
-    const instancePath = Guard.HasPropertyKey(issue, 'path') && Guard.IsArray(issue.path)
-        ? jsonPointer(issue.path)
-        : jsonPointer([]);
+    const instancePath = pathToJsonPointer(issue.path);
     return {
         instancePath,
         schemaPath: '#',

package/build/errors/normal-error.d.mts

@@ -0,0 +1,4 @@
+import type { TLocalizedValidationError } from 'typebox/error';
+import type { TJsonSchemaError } from '../validator.mjs';
+/** (Internal) Normalize a TLocalizedValidationError as TJsonSchemaError. */
+export declare function normalError(error: TLocalizedValidationError): TJsonSchemaError;

package/build/errors/normal-error.mjs

@@ -0,0 +1,5 @@
+// deno-fmt-ignore-file
+/** (Internal) Normalize a TLocalizedValidationError as TJsonSchemaError. */
+export function normalError(error) {
+    return error;
+}

package/build/errors/normal-issue.d.mts

@@ -0,0 +1,4 @@
+import type { StandardSchemaV1 } from '../_standard/standard-schema.mjs';
+import type { TStandardSchemaError } from '../validator.mjs';
+/** (Internal) Normalize a StandardSchemaV1.Issue as TStandardSchemaError. */
+export declare function normalIssue(issue: StandardSchemaV1.Issue): TStandardSchemaError;

package/build/errors/normal-issue.mjs

@@ -0,0 +1,30 @@
+// deno-fmt-ignore-file
+import { Guard } from 'typebox/guard';
+// ------------------------------------------------------------------
+// Normal: Segments
+// ------------------------------------------------------------------
+function isSegmentObjectWithKey(segment) {
+    return Guard.IsObject(segment) && Guard.HasPropertyKey(segment, 'key') && (Guard.IsBigInt(segment.key)
+        || Guard.IsBoolean(segment.key)
+        || Guard.IsString(segment.key)
+        || Guard.IsNumber(segment.key));
+}
+function normalizeSegment(segment) {
+    return isSegmentObjectWithKey(segment) ? `${segment.key}` : `${segment}`;
+}
+function normalizeSegments(segments) {
+    return segments.map(normalizeSegment);
+}
+// ------------------------------------------------------------------
+// Resolve
+// ------------------------------------------------------------------
+function resolveSegments(issue) {
+    return (Guard.HasPropertyKey(issue, 'path') && Guard.IsArray(issue.path)
+        ? issue.path
+        : []);
+}
+/** (Internal) Normalize a StandardSchemaV1.Issue as TStandardSchemaError. */
+export function normalIssue(issue) {
+    const segments = resolveSegments(issue);
+    return ({ path: normalizeSegments(segments), message: issue.message });
+}

package/build/validator.d.mts

@@ -1,35 +1,27 @@
 import { System } from 'typebox/system';
-import { TLocalizedValidationError } from 'typebox/error';
-import { StandardSchemaV1 } from './_standard/standard-schema.mjs';
-export type TStandardSchemaError = StandardSchemaV1.Issue;
-export type TJsonSchemaError = TLocalizedValidationError;
 export type TErrorFormat = 'json-schema' | 'standard-schema';
+export interface TJsonSchemaError {
+    keyword: string;
+    schemaPath: string;
+    instancePath: string;
+    params: object;
+    message: string;
+}
+export interface TStandardSchemaError {
+    path: string[];
+    message: string;
+}
 declare const Locale: typeof System.Locale;
 export type TErrorLocale = (Exclude<keyof typeof Locale, 'Get' | 'Set' | 'Reset'> & ({} & string));
 /** Internal */
 export declare function resolveErrorOptions(options?: Partial<TErrorOptions>): TErrorOptions;
 export interface TErrorOptions {
-    /**
-     * Specifies the error message generation format.
-     *
-     * Supported values are `json-schema` and `standard-schema`.
-     *
-     * Default: `json-schema`
-     */
+    /** Specifies the error format. Default: `json-schema` */
     format: TErrorFormat;
-    /**
-     * Specifies the locale used when generating error messages.
-     *
-     * This setting applies only when used with TypeScript, JSON Schema,
-     * or implementations that follow the Standard JSON Schema specification.
-     * When the compiled type is Standard Schema only, the error message
-     * will be whatever is returned from that library.
-     *
-     * Default: `en_US`
-     */
+    /** Specifies the error format. Default: `en_US` */
     locale: TErrorLocale;
 }
-export type TErrorResult<Options extends Partial<TErrorOptions>> = (Options['format'] extends 'standard-schema' ? StandardSchemaV1.Issue[] : TLocalizedValidationError[]);
+export type TErrorResult<Options extends Partial<TErrorOptions>> = (Options['format'] extends 'standard-schema' ? TStandardSchemaError[] : TJsonSchemaError[]);
 /** Abstract Base for all Validator types. */
 export declare abstract class Validator<Input extends unknown = unknown, Output extends unknown = unknown> {
     /** Returns the schema used to construct this validator */

package/build/validators/json-schema/validator.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { System } from 'typebox/system';
 import { Validator as TBValidator } from 'typebox/compile';
-import { ParseError, errorToIssue } from '../../errors/index.mjs';
+import { ParseError, errorToIssue, normalError } from '../../errors/index.mjs';
 import { Validator, resolveErrorOptions } from '../../validator.mjs';
 export class JsonSchemaValidator extends Validator {
     constructor(input) {
@@ -46,7 +46,7 @@ export class JsonSchemaValidator extends Validator {
         System.Locale.Set(System.Locale[config.locale]);
         const errors = this.validator.Errors(value);
         return (config.format === 'standard-schema'
-            ? errors.map(error => errorToIssue(error))
-            : errors);
+            ? errors.map(error => errorToIssue(normalError(error)))
+            : errors.map(error => normalError(error)));
     }
 }

package/build/validators/standard-json-schema/resolve.d.mts

@@ -1,2 +1,3 @@
 import { StandardJSONSchemaV1 } from '../../_standard/standard-schema.mjs';
-export declare function ResolveJsonSchema(input: StandardJSONSchemaV1): Record<string, unknown>;
+/** (Internal) Resolves a JsonSchema representation (need discovery mechanism here) */
+export declare function resolveJsonSchema(input: StandardJSONSchemaV1): Record<string, unknown>;

package/build/validators/standard-json-schema/resolve.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from 'typebox/guard';
-function AsOpenAPI3_0(input) {
+function OpenAPI3_0(input) {
     try {
         return input['~standard'].jsonSchema.input({ target: 'openapi-3.0' });
     }
@@ -8,7 +8,7 @@ function AsOpenAPI3_0(input) {
         return undefined;
     }
 }
-function AsDraft7(input) {
+function Draft7(input) {
     try {
         return input['~standard'].jsonSchema.input({ target: 'draft-07' });
     }
@@ -16,7 +16,7 @@ function AsDraft7(input) {
         return undefined;
     }
 }
-function AsDraft2020_12(input) {
+function Draft2020_12(input) {
     try {
         return input['~standard'].jsonSchema.input({ target: 'draft-2020-12' });
     }
@@ -24,9 +24,9 @@ function AsDraft2020_12(input) {
         return undefined;
     }
 }
-// Standard JSON Schema should provide mechanism to query supported specifications
-export function ResolveJsonSchema(input) {
-    const jsonschema = AsDraft2020_12(input) ?? AsDraft7(input) ?? AsOpenAPI3_0(input);
+/** (Internal) Resolves a JsonSchema representation (need discovery mechanism here) */
+export function resolveJsonSchema(input) {
+    const jsonschema = Draft2020_12(input) ?? Draft7(input) ?? OpenAPI3_0(input);
     if (Guard.IsUndefined(jsonschema))
         throw Error(`Vendor '${input['~standard'].vendor}' advertised itself as a Standard JSON Schema but failed to produce a schematic. Submit an issue with the vendor.`);
     return jsonschema;

package/build/validators/standard-json-schema/validator.mjs

@@ -1,14 +1,14 @@
 // deno-fmt-ignore-file
 import { System } from 'typebox/system';
 import { Validator, resolveErrorOptions } from '../../validator.mjs';
-import { ParseError, errorToIssue } from '../../errors/index.mjs';
+import { ParseError, errorToIssue, normalError } from '../../errors/index.mjs';
 import { Validator as TBValidator } from 'typebox/compile';
-import { ResolveJsonSchema } from './resolve.mjs';
+import { resolveJsonSchema } from './resolve.mjs';
 export class StandardJsonSchemaValidator extends Validator {
     constructor(input) {
         super();
         this.input = input;
-        const schema = ResolveJsonSchema(input);
+        const schema = resolveJsonSchema(input);
         this.validator = new TBValidator({}, schema);
     }
     // ----------------------------------------------------------------
@@ -48,7 +48,7 @@ export class StandardJsonSchemaValidator extends Validator {
         System.Locale.Set(System.Locale[config.locale]);
         const errors = this.validator.Errors(value);
         return (config.format === 'standard-schema'
-            ? errors.map(error => errorToIssue(error))
-            : errors);
+            ? errors.map(error => errorToIssue(normalError(error)))
+            : errors.map(error => normalError(error)));
     }
 }

package/build/validators/standard-schema/validator.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { ParseError, UnknownError, issueToError } from '../../errors/index.mjs';
+import { ParseError, UnknownError, issueToError, normalIssue } from '../../errors/index.mjs';
 import { Validator, resolveErrorOptions } from '../../validator.mjs';
 export class StandardSchemaValidator extends Validator {
     constructor(input) {
@@ -47,7 +47,7 @@ export class StandardSchemaValidator extends Validator {
         const issues = (('issues' in result) ? result.issues : []);
         const config = resolveErrorOptions(options);
         return (config.format === 'json-schema'
-            ? issues.map(issue => issueToError(issue))
-            : issues.map(issue => ({ path: issue.path, message: issue.message })));
+            ? issues.map(issue => issueToError(normalIssue(issue)))
+            : issues.map(issue => normalIssue(issue)));
     }
 }

package/build/validators/typescript/validator.d.mts

@@ -1,5 +1,5 @@
-import { Validator, type TErrorOptions, type TErrorResult } from '../../validator.mjs';
 import Type from 'typebox';
+import { Validator, type TErrorOptions, type TErrorResult } from '../../validator.mjs';
 export declare class TypeScriptValidator<Input extends string, Schema extends Type.TSchema = Type.TScript<{}, Input>, Output extends unknown = Type.Static<Schema>> extends Validator<Input, Output> {
     private readonly validator;
     private readonly script;

package/build/validators/typescript/validator.mjs

@@ -1,9 +1,9 @@
 // deno-fmt-ignore-file
+import Type from 'typebox';
 import { System } from 'typebox/system';
 import { Validator as TBValidator } from 'typebox/compile';
-import { ParseError, errorToIssue } from '../../errors/index.mjs';
+import { ParseError, errorToIssue, normalError } from '../../errors/index.mjs';
 import { Validator, resolveErrorOptions } from '../../validator.mjs';
-import Type from 'typebox';
 export class TypeScriptValidator extends Validator {
     constructor(script) {
         super();
@@ -48,7 +48,7 @@ export class TypeScriptValidator extends Validator {
         System.Locale.Set(System.Locale[config.locale]);
         const errors = this.validator.Errors(value);
         return (config.format === 'standard-schema'
-            ? errors.map(error => errorToIssue(error))
-            : errors);
+            ? errors.map(error => errorToIssue(normalError(error)))
+            : errors.map(error => normalError(error)));
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typedriver",
   "description": "High Performance Driver for Runtime Type System Integration",
-  "version": "0.8.7",
+  "version": "0.8.8",
   "keywords": [
     "typescript",
     "json-schema",

package/readme.md

@@ -34,8 +34,6 @@ const Vector3 = compile(`{
   z: number
 }`)
 
-declare const value: unknown
-
 const position = Vector3.parse(value)            // const position: {
                                                  //   x: number,
                                                  //   y: number,
@@ -65,7 +63,7 @@ License MIT
 - [Locales](#Locales)
 - [Static](#Static)
 - [Script](#Script)
-- [Reflect](#Schema)
+- [Reflect](#Reflect)
 - [Extensions](#Extensions)
 - [Accelerate](#Accelerate)
 - [Compression](#Compression)