Version 1.0.23 (#1378)

* Revert Standard Schema Issue Mapping

* ChangeLog

* Version

* Test

* Lock (Types)

Author: sinclairzx81

changelog/1.0.0.md

@@ -3,6 +3,9 @@
 ---
 
 ### Version Updates
+
+- [Revision 1.0.23](https://github.com/sinclairzx81/typebox/pull/1378)
+  - Revert Standard Schema Error Path Translation | Provide Translation Via Example
 - [Revision 1.0.22](https://github.com/sinclairzx81/typebox/pull/1375)
   - Resolve Socket.Dev False Positive
 - [Revision 1.0.21](https://github.com/sinclairzx81/typebox/pull/1374)

deno.lock

@@ -0,0 +1,73 @@
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+
+export 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"];
+
+  // biome-ignore lint/complexity/noUselessEmptyExport: needed for granular visibility control of TS namespace
+  export {};
+}

example/standard/standard-schema-v1.ts

@@ -0,0 +1,93 @@
+/*--------------------------------------------------------------------------
+
+TypeBox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2025 Haydn Paterson 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { type TLocalizedValidationError, type TValidationErrorBase, type TStandardSchemaV1Error, IsLocalizedValidationError } from 'typebox/error'
+import { StandardSchemaV1 } from './standard-schema-v1.ts'
+import Guard from 'typebox/guard'
+
+// --------------------------------------------------------
+// StandardSchema: PathSegments
+// --------------------------------------------------------
+function PathSegments(pointer: string): string[] {
+  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: TValidationErrorBase): error is TStandardSchemaV1Error {
+  return Guard.IsEqual(error.keyword, '~standard')
+}
+// --------------------------------------------------------
+// IssuesFromLocalizedError
+// --------------------------------------------------------
+function IssuesFromStandardSchemaV1Error(error: TStandardSchemaV1Error): StandardSchemaV1.Issue[] {
+  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: TLocalizedValidationError): StandardSchemaV1.Issue[] {
+  const path = PathSegments(error.instancePath)
+  return [{ path, message: error.message  }]
+}
+function IssuesFromLocalizedError(error: TLocalizedValidationError): StandardSchemaV1.Issue[] {
+  return IsStandardSchemaV1Error(error) 
+    ? IssuesFromStandardSchemaV1Error(error) 
+    : IssuesFromRegularError(error)
+}
+// --------------------------------------------------------
+// IssuesFromUnknown
+// --------------------------------------------------------
+function IssuesFromUnknown(error: object): StandardSchemaV1.Issue[] {
+  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 } as StandardSchemaV1.Issue]
+}
+// --------------------------------------------------------
+// CreateIssues
+// --------------------------------------------------------
+function FromError(error: object): StandardSchemaV1.Issue[] {
+  return IsLocalizedValidationError(error)
+    ? IssuesFromLocalizedError(error)
+    : IssuesFromUnknown(error)
+}
+// --------------------------------------------------------
+// ToStandardSchemaV1Issues
+// --------------------------------------------------------
+export type TErrorLike = TValidationErrorBase | StandardSchemaV1.Issue
+
+/** Transforms an array of ErrorLikes into a consistent StandardSchemaV1.Issue[] array. */
+export function ToStandardSchemaV1Issues(errorLikes: TErrorLike[]): StandardSchemaV1.Issue[] {
+  return errorLikes.reduce<StandardSchemaV1.Issue[]>((result, error) => {
+    return [...result, ...FromError(error)]
+  }, [])
+}