zod-error-map 0.2.2 → 0.2.4

package/dist/index.cjs

@@ -0,0 +1,193 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.js
+var index_exports = {};
+__export(index_exports, {
+  ErrorCode: () => ErrorCode,
+  FormatType: () => FormatType,
+  buildInvalidTypeMessage: () => buildInvalidTypeMessage,
+  buildTooBigMessage: () => buildTooBigMessage,
+  buildTooSmallMessage: () => buildTooSmallMessage,
+  createCustomMessageBuilder: () => createCustomMessageBuilder,
+  createDefaultBuilders: () => createDefaultBuilders,
+  createErrorMapper: () => createErrorMapper,
+  createFormatMessageBuilder: () => createFormatMessageBuilder,
+  createZodErrorMap: () => createZodErrorMap,
+  defaultErrorMapper: () => defaultErrorMapper,
+  defaultFormatMessages: () => defaultFormatMessages,
+  getInputDescription: () => getInputDescription,
+  setZodErrorMap: () => setZodErrorMap
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/constants/error-codes.js
+var ErrorCode = (
+  /** @type {const} */
+  {
+    INVALID_TYPE: "invalid_type",
+    TOO_SMALL: "too_small",
+    TOO_BIG: "too_big",
+    INVALID_FORMAT: "invalid_format",
+    CUSTOM: "custom"
+  }
+);
+var FormatType = (
+  /** @type {const} */
+  {
+    EMAIL: "email",
+    UUID: "uuid",
+    URL: "url",
+    REGEX: "regex",
+    CUID: "cuid",
+    CUID2: "cuid2",
+    ULID: "ulid",
+    IP: "ip",
+    EMOJI: "emoji",
+    DATE: "date",
+    DATETIME: "datetime",
+    TIME: "time"
+  }
+);
+
+// src/domain/builders/message-builders.js
+function getInputDescription(input) {
+  if (input === void 0) return "undefined";
+  if (input === null) return "null";
+  if (Array.isArray(input)) return "array";
+  return typeof input;
+}
+var defaultFormatMessages = {
+  [FormatType.EMAIL]: (label) => `The ${label.quoted} must be a valid email address`,
+  [FormatType.UUID]: (label) => `The ${label.quoted} must be a valid UUID`,
+  [FormatType.URL]: (label) => `The ${label.quoted} is invalid`,
+  [FormatType.REGEX]: (label) => `The ${label.quoted} has an invalid format`,
+  [FormatType.CUID]: (label) => `The ${label.quoted} must be a valid CUID`,
+  [FormatType.CUID2]: (label) => `The ${label.quoted} must be a valid CUID2`,
+  [FormatType.ULID]: (label) => `The ${label.quoted} must be a valid ULID`,
+  [FormatType.IP]: (label) => `The ${label.quoted} must be a valid IP address`,
+  [FormatType.DATE]: (label) => `The ${label.quoted} must be a valid date`,
+  [FormatType.DATETIME]: (label) => `The ${label.quoted} must be a valid datetime`,
+  [FormatType.TIME]: (label) => `The ${label.quoted} must be a valid time`
+};
+function buildInvalidTypeMessage(issue, label) {
+  const received = getInputDescription(issue.input);
+  if (received === "undefined") {
+    return `The ${label.bare} is required`;
+  }
+  return `Expected ${issue.expected} for ${label.quoted}, received ${received}`;
+}
+function buildTooSmallMessage(issue, label) {
+  const min = Number(issue.minimum) || 0;
+  return `The ${label.quoted} must contain at least ${min} characters`;
+}
+function buildTooBigMessage(issue, label) {
+  const max = Number(issue.maximum) || 0;
+  return `The ${label.quoted} must contain at most ${max} characters`;
+}
+function createFormatMessageBuilder(formatMessages = defaultFormatMessages) {
+  return (issue, label) => {
+    const format = issue.format || "";
+    const messageBuilder = formatMessages[format];
+    if (messageBuilder) {
+      return messageBuilder(label);
+    }
+    return `The ${label.quoted} has an invalid format`;
+  };
+}
+function createCustomMessageBuilder(defaultError) {
+  return (issue, _label) => issue.message || defaultError;
+}
+function createDefaultBuilders(defaultError, formatMessages) {
+  return {
+    [ErrorCode.INVALID_TYPE]: buildInvalidTypeMessage,
+    [ErrorCode.TOO_SMALL]: buildTooSmallMessage,
+    [ErrorCode.TOO_BIG]: buildTooBigMessage,
+    [ErrorCode.INVALID_FORMAT]: createFormatMessageBuilder(formatMessages),
+    [ErrorCode.CUSTOM]: createCustomMessageBuilder(defaultError)
+  };
+}
+
+// src/domain/mappers/error-mapper.js
+var DEFAULT_ERROR = "Invalid input";
+function isRawIssue(issue) {
+  return typeof issue === "object" && issue !== null && "code" in issue;
+}
+function getLabel(issue) {
+  const path = issue.path ?? [];
+  const field = path[path.length - 1];
+  if (typeof field === "string") {
+    return { bare: field, quoted: `'${field}'` };
+  }
+  return { bare: "value", quoted: "value" };
+}
+function createErrorMapper(config = {}) {
+  const defaultError = config.defaultError ?? DEFAULT_ERROR;
+  const defaultBuilders = createDefaultBuilders(defaultError, config.formatMessages);
+  const builders = { ...defaultBuilders, ...config.builders };
+  function buildMessage(issue) {
+    const label = getLabel(issue);
+    const builder = builders[issue.code];
+    if (builder) {
+      return builder(issue, label);
+    }
+    return issue.message || defaultError;
+  }
+  function format(issue) {
+    if (!isRawIssue(issue)) return defaultError;
+    return buildMessage(issue);
+  }
+  function createErrorMap() {
+    return format;
+  }
+  return { format, createErrorMap };
+}
+var defaultErrorMapper = createErrorMapper();
+
+// src/adapters/zod/integration.js
+function setZodErrorMap(z, config) {
+  const mapper = createErrorMapper(config);
+  z.config({
+    customError: (issue) => mapper.format(issue)
+  });
+}
+function createZodErrorMap(config) {
+  const mapper = createErrorMapper(config);
+  return (issue, _ctx) => {
+    const message = mapper.format(issue);
+    return { message };
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ErrorCode,
+  FormatType,
+  buildInvalidTypeMessage,
+  buildTooBigMessage,
+  buildTooSmallMessage,
+  createCustomMessageBuilder,
+  createDefaultBuilders,
+  createErrorMapper,
+  createFormatMessageBuilder,
+  createZodErrorMap,
+  defaultErrorMapper,
+  defaultFormatMessages,
+  getInputDescription,
+  setZodErrorMap
+});

package/dist/index.d.cts

@@ -0,0 +1,79 @@
+import * as zod from 'zod';
+
+interface Label {
+  bare: string
+  quoted: string
+}
+
+interface RawIssue {
+  code: string
+  path: Array<string | number>
+  input?: unknown
+  expected?: string
+  minimum?: number
+  maximum?: number
+  format?: string
+  message?: string
+}
+
+type MessageBuilder = (issue: RawIssue, label: Label) => string
+
+type FormatMessageBuilder = (label: Label) => string
+
+interface ErrorMapConfig {
+  defaultError?: string
+  builders?: Record<string, MessageBuilder>
+  formatMessages?: Record<string, FormatMessageBuilder>
+}
+
+interface ErrorMapper {
+  format: (issue: unknown) => string
+  createErrorMap: () => (issue: unknown) => string
+}
+
+declare const ErrorCode: {
+  readonly INVALID_TYPE: 'invalid_type'
+  readonly TOO_SMALL: 'too_small'
+  readonly TOO_BIG: 'too_big'
+  readonly INVALID_FORMAT: 'invalid_format'
+  readonly CUSTOM: 'custom'
+}
+
+declare const FormatType: {
+  readonly EMAIL: 'email'
+  readonly UUID: 'uuid'
+  readonly URL: 'url'
+  readonly REGEX: 'regex'
+  readonly CUID: 'cuid'
+  readonly CUID2: 'cuid2'
+  readonly ULID: 'ulid'
+  readonly IP: 'ip'
+  readonly EMOJI: 'emoji'
+  readonly DATE: 'date'
+  readonly DATETIME: 'datetime'
+  readonly TIME: 'time'
+}
+
+declare function createErrorMapper(config?: ErrorMapConfig): ErrorMapper
+declare const defaultErrorMapper: ErrorMapper
+
+declare function getInputDescription(input: unknown): string
+declare const defaultFormatMessages: Record<string, (label: Label) => string>
+declare function buildInvalidTypeMessage(issue: RawIssue, label: Label): string
+declare function buildTooSmallMessage(issue: RawIssue, label: Label): string
+declare function buildTooBigMessage(issue: RawIssue, label: Label): string
+declare function createFormatMessageBuilder(
+  formatMessages?: Record<string, (label: Label) => string>
+): MessageBuilder
+declare function createCustomMessageBuilder(defaultError: string): MessageBuilder
+declare function createDefaultBuilders(
+  defaultError: string,
+  formatMessages?: Record<string, (label: Label) => string>
+): Record<string, MessageBuilder>
+
+declare function setZodErrorMap(z: typeof zod.z, config?: ErrorMapConfig): void
+declare function createZodErrorMap(
+  config?: ErrorMapConfig
+): (issue: unknown, ctx: unknown) => { message: string }
+
+export { ErrorCode, type ErrorMapConfig, type ErrorMapper, type FormatMessageBuilder, FormatType, type Label, type MessageBuilder, type RawIssue, buildInvalidTypeMessage, buildTooBigMessage, buildTooSmallMessage, createCustomMessageBuilder, createDefaultBuilders, createErrorMapper, createFormatMessageBuilder, createZodErrorMap, defaultErrorMapper, defaultFormatMessages, getInputDescription, setZodErrorMap };

package/dist/index.d.ts

@@ -0,0 +1,79 @@
+import * as zod from 'zod';
+
+interface Label {
+  bare: string
+  quoted: string
+}
+
+interface RawIssue {
+  code: string
+  path: Array<string | number>
+  input?: unknown
+  expected?: string
+  minimum?: number
+  maximum?: number
+  format?: string
+  message?: string
+}
+
+type MessageBuilder = (issue: RawIssue, label: Label) => string
+
+type FormatMessageBuilder = (label: Label) => string
+
+interface ErrorMapConfig {
+  defaultError?: string
+  builders?: Record<string, MessageBuilder>
+  formatMessages?: Record<string, FormatMessageBuilder>
+}
+
+interface ErrorMapper {
+  format: (issue: unknown) => string
+  createErrorMap: () => (issue: unknown) => string
+}
+
+declare const ErrorCode: {
+  readonly INVALID_TYPE: 'invalid_type'
+  readonly TOO_SMALL: 'too_small'
+  readonly TOO_BIG: 'too_big'
+  readonly INVALID_FORMAT: 'invalid_format'
+  readonly CUSTOM: 'custom'
+}
+
+declare const FormatType: {
+  readonly EMAIL: 'email'
+  readonly UUID: 'uuid'
+  readonly URL: 'url'
+  readonly REGEX: 'regex'
+  readonly CUID: 'cuid'
+  readonly CUID2: 'cuid2'
+  readonly ULID: 'ulid'
+  readonly IP: 'ip'
+  readonly EMOJI: 'emoji'
+  readonly DATE: 'date'
+  readonly DATETIME: 'datetime'
+  readonly TIME: 'time'
+}
+
+declare function createErrorMapper(config?: ErrorMapConfig): ErrorMapper
+declare const defaultErrorMapper: ErrorMapper
+
+declare function getInputDescription(input: unknown): string
+declare const defaultFormatMessages: Record<string, (label: Label) => string>
+declare function buildInvalidTypeMessage(issue: RawIssue, label: Label): string
+declare function buildTooSmallMessage(issue: RawIssue, label: Label): string
+declare function buildTooBigMessage(issue: RawIssue, label: Label): string
+declare function createFormatMessageBuilder(
+  formatMessages?: Record<string, (label: Label) => string>
+): MessageBuilder
+declare function createCustomMessageBuilder(defaultError: string): MessageBuilder
+declare function createDefaultBuilders(
+  defaultError: string,
+  formatMessages?: Record<string, (label: Label) => string>
+): Record<string, MessageBuilder>
+
+declare function setZodErrorMap(z: typeof zod.z, config?: ErrorMapConfig): void
+declare function createZodErrorMap(
+  config?: ErrorMapConfig
+): (issue: unknown, ctx: unknown) => { message: string }
+
+export { ErrorCode, type ErrorMapConfig, type ErrorMapper, type FormatMessageBuilder, FormatType, type Label, type MessageBuilder, type RawIssue, buildInvalidTypeMessage, buildTooBigMessage, buildTooSmallMessage, createCustomMessageBuilder, createDefaultBuilders, createErrorMapper, createFormatMessageBuilder, createZodErrorMap, defaultErrorMapper, defaultFormatMessages, getInputDescription, setZodErrorMap };

package/dist/index.js

@@ -0,0 +1,153 @@
+// src/core/constants/error-codes.js
+var ErrorCode = (
+  /** @type {const} */
+  {
+    INVALID_TYPE: "invalid_type",
+    TOO_SMALL: "too_small",
+    TOO_BIG: "too_big",
+    INVALID_FORMAT: "invalid_format",
+    CUSTOM: "custom"
+  }
+);
+var FormatType = (
+  /** @type {const} */
+  {
+    EMAIL: "email",
+    UUID: "uuid",
+    URL: "url",
+    REGEX: "regex",
+    CUID: "cuid",
+    CUID2: "cuid2",
+    ULID: "ulid",
+    IP: "ip",
+    EMOJI: "emoji",
+    DATE: "date",
+    DATETIME: "datetime",
+    TIME: "time"
+  }
+);
+
+// src/domain/builders/message-builders.js
+function getInputDescription(input) {
+  if (input === void 0) return "undefined";
+  if (input === null) return "null";
+  if (Array.isArray(input)) return "array";
+  return typeof input;
+}
+var defaultFormatMessages = {
+  [FormatType.EMAIL]: (label) => `The ${label.quoted} must be a valid email address`,
+  [FormatType.UUID]: (label) => `The ${label.quoted} must be a valid UUID`,
+  [FormatType.URL]: (label) => `The ${label.quoted} is invalid`,
+  [FormatType.REGEX]: (label) => `The ${label.quoted} has an invalid format`,
+  [FormatType.CUID]: (label) => `The ${label.quoted} must be a valid CUID`,
+  [FormatType.CUID2]: (label) => `The ${label.quoted} must be a valid CUID2`,
+  [FormatType.ULID]: (label) => `The ${label.quoted} must be a valid ULID`,
+  [FormatType.IP]: (label) => `The ${label.quoted} must be a valid IP address`,
+  [FormatType.DATE]: (label) => `The ${label.quoted} must be a valid date`,
+  [FormatType.DATETIME]: (label) => `The ${label.quoted} must be a valid datetime`,
+  [FormatType.TIME]: (label) => `The ${label.quoted} must be a valid time`
+};
+function buildInvalidTypeMessage(issue, label) {
+  const received = getInputDescription(issue.input);
+  if (received === "undefined") {
+    return `The ${label.bare} is required`;
+  }
+  return `Expected ${issue.expected} for ${label.quoted}, received ${received}`;
+}
+function buildTooSmallMessage(issue, label) {
+  const min = Number(issue.minimum) || 0;
+  return `The ${label.quoted} must contain at least ${min} characters`;
+}
+function buildTooBigMessage(issue, label) {
+  const max = Number(issue.maximum) || 0;
+  return `The ${label.quoted} must contain at most ${max} characters`;
+}
+function createFormatMessageBuilder(formatMessages = defaultFormatMessages) {
+  return (issue, label) => {
+    const format = issue.format || "";
+    const messageBuilder = formatMessages[format];
+    if (messageBuilder) {
+      return messageBuilder(label);
+    }
+    return `The ${label.quoted} has an invalid format`;
+  };
+}
+function createCustomMessageBuilder(defaultError) {
+  return (issue, _label) => issue.message || defaultError;
+}
+function createDefaultBuilders(defaultError, formatMessages) {
+  return {
+    [ErrorCode.INVALID_TYPE]: buildInvalidTypeMessage,
+    [ErrorCode.TOO_SMALL]: buildTooSmallMessage,
+    [ErrorCode.TOO_BIG]: buildTooBigMessage,
+    [ErrorCode.INVALID_FORMAT]: createFormatMessageBuilder(formatMessages),
+    [ErrorCode.CUSTOM]: createCustomMessageBuilder(defaultError)
+  };
+}
+
+// src/domain/mappers/error-mapper.js
+var DEFAULT_ERROR = "Invalid input";
+function isRawIssue(issue) {
+  return typeof issue === "object" && issue !== null && "code" in issue;
+}
+function getLabel(issue) {
+  const path = issue.path ?? [];
+  const field = path[path.length - 1];
+  if (typeof field === "string") {
+    return { bare: field, quoted: `'${field}'` };
+  }
+  return { bare: "value", quoted: "value" };
+}
+function createErrorMapper(config = {}) {
+  const defaultError = config.defaultError ?? DEFAULT_ERROR;
+  const defaultBuilders = createDefaultBuilders(defaultError, config.formatMessages);
+  const builders = { ...defaultBuilders, ...config.builders };
+  function buildMessage(issue) {
+    const label = getLabel(issue);
+    const builder = builders[issue.code];
+    if (builder) {
+      return builder(issue, label);
+    }
+    return issue.message || defaultError;
+  }
+  function format(issue) {
+    if (!isRawIssue(issue)) return defaultError;
+    return buildMessage(issue);
+  }
+  function createErrorMap() {
+    return format;
+  }
+  return { format, createErrorMap };
+}
+var defaultErrorMapper = createErrorMapper();
+
+// src/adapters/zod/integration.js
+function setZodErrorMap(z, config) {
+  const mapper = createErrorMapper(config);
+  z.config({
+    customError: (issue) => mapper.format(issue)
+  });
+}
+function createZodErrorMap(config) {
+  const mapper = createErrorMapper(config);
+  return (issue, _ctx) => {
+    const message = mapper.format(issue);
+    return { message };
+  };
+}
+export {
+  ErrorCode,
+  FormatType,
+  buildInvalidTypeMessage,
+  buildTooBigMessage,
+  buildTooSmallMessage,
+  createCustomMessageBuilder,
+  createDefaultBuilders,
+  createErrorMapper,
+  createFormatMessageBuilder,
+  createZodErrorMap,
+  defaultErrorMapper,
+  defaultFormatMessages,
+  getInputDescription,
+  setZodErrorMap
+};

package/package.json

@@ -1,23 +1,29 @@
 {
   "name": "zod-error-map",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Type-safe, customizable error message mapping for Zod validation",
   "type": "module",
-  "main": "src/index.js",
-  "types": "src/index.d.ts",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./src/index.js",
-      "types": "./src/index.d.ts"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     }
   },
   "files": [
-    "src/**/*.js",
-    "src/**/*.d.ts",
-    "!src/**/*.test.js"
+    "dist"
   ],
   "scripts": {
-    "test": "node --test 'tests/**/*.test.js'",
+    "build": "tsup",
+    "test": "node --test tests/*.test.js",
     "typecheck": "tsc"
   },
   "keywords": [
@@ -42,6 +48,7 @@
     "zod": "^3.0.0 || ^4.0.0"
   },
   "devDependencies": {
+    "tsup": "^8.0.0",
     "typescript": "^5.0.0",
     "zod": "^4.1.0"
   },

package/src/adapters/index.js

@@ -1,4 +0,0 @@
-export {
-  setZodErrorMap,
-  createZodErrorMap,
-} from './zod/index.js'

package/src/adapters/zod/index.js

@@ -1,4 +0,0 @@
-export {
-  setZodErrorMap,
-  createZodErrorMap,
-} from './integration.js'

package/src/adapters/zod/integration.js

@@ -1,31 +0,0 @@
-/**
- * @typedef {import('../../core/types/index.js').ErrorMapConfig} ErrorMapConfig
- */
-
-import { createErrorMapper } from '../../domain/mappers/index.js'
-
-/**
- * Sets the global Zod error map using z.config()
- * @param {import('zod')} z - The Zod instance
- * @param {ErrorMapConfig} [config] - Optional configuration
- * @returns {void}
- */
-export function setZodErrorMap(z, config) {
-  const mapper = createErrorMapper(config)
-  z.config({
-    customError: (issue) => mapper.format(issue),
-  })
-}
-
-/**
- * Creates a Zod error map function compatible with z.setErrorMap() (Zod v3)
- * @param {ErrorMapConfig} [config] - Optional configuration
- * @returns {(issue: unknown, ctx: unknown) => { message: string }}
- */
-export function createZodErrorMap(config) {
-  const mapper = createErrorMapper(config)
-  return (issue, _ctx) => {
-    const message = mapper.format(issue)
-    return { message }
-  }
-}

package/src/core/constants/error-codes.js

@@ -1,32 +0,0 @@
-/**
- * Zod error codes
- * @readonly
- * @enum {string}
- */
-export const ErrorCode = /** @type {const} */ ({
-  INVALID_TYPE: 'invalid_type',
-  TOO_SMALL: 'too_small',
-  TOO_BIG: 'too_big',
-  INVALID_FORMAT: 'invalid_format',
-  CUSTOM: 'custom',
-})
-
-/**
- * Format types for invalid_format errors
- * @readonly
- * @enum {string}
- */
-export const FormatType = /** @type {const} */ ({
-  EMAIL: 'email',
-  UUID: 'uuid',
-  URL: 'url',
-  REGEX: 'regex',
-  CUID: 'cuid',
-  CUID2: 'cuid2',
-  ULID: 'ulid',
-  IP: 'ip',
-  EMOJI: 'emoji',
-  DATE: 'date',
-  DATETIME: 'datetime',
-  TIME: 'time',
-})

package/src/core/constants/index.js

@@ -1 +0,0 @@
-export { ErrorCode, FormatType } from './error-codes.js'

package/src/core/index.js

@@ -1 +0,0 @@
-export { ErrorCode, FormatType } from './constants/index.js'

package/src/core/types/index.js

@@ -1,37 +0,0 @@
-/**
- * @typedef {object} Label
- * @property {string} bare - The field name without quotes
- * @property {string} quoted - The field name with quotes
- */
-
-/**
- * @typedef {object} RawIssue
- * @property {string} code - The error code from Zod
- * @property {Array<string | number>} path - The path to the field
- * @property {unknown} [input] - The input value that caused the error
- * @property {string} [expected] - The expected type
- * @property {number} [minimum] - Minimum value/length constraint
- * @property {number} [maximum] - Maximum value/length constraint
- * @property {string} [format] - Format type (email, uuid, url, etc.)
- * @property {string} [message] - Custom error message
- */
-
-/**
- * @callback MessageBuilder
- * @param {RawIssue} issue - The raw Zod issue
- * @param {Label} label - The field label
- * @returns {string} The formatted error message
- */
-
-/**
- * @typedef {(label: Label) => string} FormatMessageBuilder
- */
-
-/**
- * @typedef {object} ErrorMapConfig
- * @property {string} [defaultError] - Default error message
- * @property {Record<string, MessageBuilder>} [builders] - Custom message builders by error code
- * @property {Record<string, FormatMessageBuilder>} [formatMessages] - Custom messages for format errors
- */
-
-export {}

package/src/domain/builders/index.js

@@ -1,10 +0,0 @@
-export {
-  getInputDescription,
-  defaultFormatMessages,
-  buildInvalidTypeMessage,
-  buildTooSmallMessage,
-  buildTooBigMessage,
-  createFormatMessageBuilder,
-  createCustomMessageBuilder,
-  createDefaultBuilders,
-} from './message-builders.js'

package/src/domain/builders/message-builders.js

@@ -1,108 +0,0 @@
-import { ErrorCode, FormatType } from '../../core/constants/index.js'
-
-/**
- * @typedef {import('../../core/types/index.js').RawIssue} RawIssue
- * @typedef {import('../../core/types/index.js').Label} Label
- * @typedef {import('../../core/types/index.js').MessageBuilder} MessageBuilder
- */
-
-/**
- * Gets a human-readable description of the input type
- * @param {unknown} input
- * @returns {string}
- */
-export function getInputDescription(input) {
-  if (input === undefined) return 'undefined'
-  if (input === null) return 'null'
-  if (Array.isArray(input)) return 'array'
-  return typeof input
-}
-
-/**
- * Default format error messages
- * @type {Record<string, (label: Label) => string>}
- */
-export const defaultFormatMessages = {
-  [FormatType.EMAIL]: (label) => `The ${label.quoted} must be a valid email address`,
-  [FormatType.UUID]: (label) => `The ${label.quoted} must be a valid UUID`,
-  [FormatType.URL]: (label) => `The ${label.quoted} is invalid`,
-  [FormatType.REGEX]: (label) => `The ${label.quoted} has an invalid format`,
-  [FormatType.CUID]: (label) => `The ${label.quoted} must be a valid CUID`,
-  [FormatType.CUID2]: (label) => `The ${label.quoted} must be a valid CUID2`,
-  [FormatType.ULID]: (label) => `The ${label.quoted} must be a valid ULID`,
-  [FormatType.IP]: (label) => `The ${label.quoted} must be a valid IP address`,
-  [FormatType.DATE]: (label) => `The ${label.quoted} must be a valid date`,
-  [FormatType.DATETIME]: (label) => `The ${label.quoted} must be a valid datetime`,
-  [FormatType.TIME]: (label) => `The ${label.quoted} must be a valid time`,
-}
-
-/**
- * Builds error message for invalid_type errors
- * @type {MessageBuilder}
- */
-export function buildInvalidTypeMessage(issue, label) {
-  const received = getInputDescription(issue.input)
-  if (received === 'undefined') {
-    return `The ${label.bare} is required`
-  }
-  return `Expected ${issue.expected} for ${label.quoted}, received ${received}`
-}
-
-/**
- * Builds error message for too_small errors
- * @type {MessageBuilder}
- */
-export function buildTooSmallMessage(issue, label) {
-  const min = Number(issue.minimum) || 0
-  return `The ${label.quoted} must contain at least ${min} characters`
-}
-
-/**
- * Builds error message for too_big errors
- * @type {MessageBuilder}
- */
-export function buildTooBigMessage(issue, label) {
-  const max = Number(issue.maximum) || 0
-  return `The ${label.quoted} must contain at most ${max} characters`
-}
-
-/**
- * Creates a format message builder with custom format messages
- * @param {Record<string, (label: Label) => string>} [formatMessages]
- * @returns {MessageBuilder}
- */
-export function createFormatMessageBuilder(formatMessages = defaultFormatMessages) {
-  return (issue, label) => {
-    const format = issue.format || ''
-    const messageBuilder = formatMessages[format]
-    if (messageBuilder) {
-      return messageBuilder(label)
-    }
-    return `The ${label.quoted} has an invalid format`
-  }
-}
-
-/**
- * Builds error message for custom errors
- * @param {string} defaultError
- * @returns {MessageBuilder}
- */
-export function createCustomMessageBuilder(defaultError) {
-  return (issue, _label) => issue.message || defaultError
-}
-
-/**
- * Creates the default message builders map
- * @param {string} defaultError
- * @param {Record<string, (label: Label) => string>} [formatMessages]
- * @returns {Record<string, MessageBuilder>}
- */
-export function createDefaultBuilders(defaultError, formatMessages) {
-  return {
-    [ErrorCode.INVALID_TYPE]: buildInvalidTypeMessage,
-    [ErrorCode.TOO_SMALL]: buildTooSmallMessage,
-    [ErrorCode.TOO_BIG]: buildTooBigMessage,
-    [ErrorCode.INVALID_FORMAT]: createFormatMessageBuilder(formatMessages),
-    [ErrorCode.CUSTOM]: createCustomMessageBuilder(defaultError),
-  }
-}

package/src/domain/index.js

@@ -1,15 +0,0 @@
-export {
-  createErrorMapper,
-  defaultErrorMapper,
-} from './mappers/index.js'
-
-export {
-  getInputDescription,
-  defaultFormatMessages,
-  buildInvalidTypeMessage,
-  buildTooSmallMessage,
-  buildTooBigMessage,
-  createFormatMessageBuilder,
-  createCustomMessageBuilder,
-  createDefaultBuilders,
-} from './builders/index.js'

package/src/domain/mappers/error-mapper.js

@@ -1,87 +0,0 @@
-import { createDefaultBuilders } from '../builders/index.js'
-
-/**
- * @typedef {import('../../core/types/index.js').RawIssue} RawIssue
- * @typedef {import('../../core/types/index.js').Label} Label
- * @typedef {import('../../core/types/index.js').MessageBuilder} MessageBuilder
- * @typedef {import('../../core/types/index.js').ErrorMapConfig} ErrorMapConfig
- */
-
-const DEFAULT_ERROR = 'Invalid input'
-
-/**
- * Checks if the issue is a valid RawIssue
- * @param {unknown} issue
- * @returns {issue is RawIssue}
- */
-function isRawIssue(issue) {
-  return (
-    typeof issue === 'object' &&
-    issue !== null &&
-    'code' in issue
-  )
-}
-
-/**
- * Gets the label from the issue path
- * @param {RawIssue} issue
- * @returns {Label}
- */
-function getLabel(issue) {
-  const path = issue.path ?? []
-  const field = path[path.length - 1]
-  if (typeof field === 'string') {
-    return { bare: field, quoted: `'${field}'` }
-  }
-  return { bare: 'value', quoted: 'value' }
-}
-
-/**
- * Creates a Zod error mapper with customizable message builders
- * @param {ErrorMapConfig} [config]
- * @returns {{ format: (issue: unknown) => string, createErrorMap: () => (issue: unknown) => string }}
- */
-export function createErrorMapper(config = {}) {
-  const defaultError = config.defaultError ?? DEFAULT_ERROR
-  const defaultBuilders = createDefaultBuilders(defaultError, config.formatMessages)
-  const builders = { ...defaultBuilders, ...config.builders }
-
-  /**
-   * Builds the error message for a Zod issue
-   * @param {RawIssue} issue
-   * @returns {string}
-   */
-  function buildMessage(issue) {
-    const label = getLabel(issue)
-    const builder = builders[issue.code]
-    if (builder) {
-      return builder(issue, label)
-    }
-    return issue.message || defaultError
-  }
-
-  /**
-   * Formats a Zod issue into a human-readable message
-   * @param {unknown} issue
-   * @returns {string}
-   */
-  function format(issue) {
-    if (!isRawIssue(issue)) return defaultError
-    return buildMessage(issue)
-  }
-
-  /**
-   * Creates an error map function for Zod
-   * @returns {(issue: unknown) => string}
-   */
-  function createErrorMap() {
-    return format
-  }
-
-  return { format, createErrorMap }
-}
-
-/**
- * Default error mapper instance
- */
-export const defaultErrorMapper = createErrorMapper()

package/src/domain/mappers/index.js

@@ -1,4 +0,0 @@
-export {
-  createErrorMapper,
-  defaultErrorMapper,
-} from './error-mapper.js'

package/src/index.d.ts

@@ -1,77 +0,0 @@
-import type { z } from 'zod'
-
-export interface Label {
-  bare: string
-  quoted: string
-}
-
-export interface RawIssue {
-  code: string
-  path: Array<string | number>
-  input?: unknown
-  expected?: string
-  minimum?: number
-  maximum?: number
-  format?: string
-  message?: string
-}
-
-export type MessageBuilder = (issue: RawIssue, label: Label) => string
-
-export type FormatMessageBuilder = (label: Label) => string
-
-export interface ErrorMapConfig {
-  defaultError?: string
-  builders?: Record<string, MessageBuilder>
-  formatMessages?: Record<string, FormatMessageBuilder>
-}
-
-export interface ErrorMapper {
-  format: (issue: unknown) => string
-  createErrorMap: () => (issue: unknown) => string
-}
-
-export declare const ErrorCode: {
-  readonly INVALID_TYPE: 'invalid_type'
-  readonly TOO_SMALL: 'too_small'
-  readonly TOO_BIG: 'too_big'
-  readonly INVALID_FORMAT: 'invalid_format'
-  readonly CUSTOM: 'custom'
-}
-
-export declare const FormatType: {
-  readonly EMAIL: 'email'
-  readonly UUID: 'uuid'
-  readonly URL: 'url'
-  readonly REGEX: 'regex'
-  readonly CUID: 'cuid'
-  readonly CUID2: 'cuid2'
-  readonly ULID: 'ulid'
-  readonly IP: 'ip'
-  readonly EMOJI: 'emoji'
-  readonly DATE: 'date'
-  readonly DATETIME: 'datetime'
-  readonly TIME: 'time'
-}
-
-export declare function createErrorMapper(config?: ErrorMapConfig): ErrorMapper
-export declare const defaultErrorMapper: ErrorMapper
-
-export declare function getInputDescription(input: unknown): string
-export declare const defaultFormatMessages: Record<string, (label: Label) => string>
-export declare function buildInvalidTypeMessage(issue: RawIssue, label: Label): string
-export declare function buildTooSmallMessage(issue: RawIssue, label: Label): string
-export declare function buildTooBigMessage(issue: RawIssue, label: Label): string
-export declare function createFormatMessageBuilder(
-  formatMessages?: Record<string, (label: Label) => string>
-): MessageBuilder
-export declare function createCustomMessageBuilder(defaultError: string): MessageBuilder
-export declare function createDefaultBuilders(
-  defaultError: string,
-  formatMessages?: Record<string, (label: Label) => string>
-): Record<string, MessageBuilder>
-
-export declare function setZodErrorMap(z: typeof import('zod').z, config?: ErrorMapConfig): void
-export declare function createZodErrorMap(
-  config?: ErrorMapConfig
-): (issue: unknown, ctx: unknown) => { message: string }

package/src/index.js

@@ -1,19 +0,0 @@
-export { ErrorCode, FormatType } from './core/index.js'
-
-export {
-  createErrorMapper,
-  defaultErrorMapper,
-  getInputDescription,
-  defaultFormatMessages,
-  buildInvalidTypeMessage,
-  buildTooSmallMessage,
-  buildTooBigMessage,
-  createFormatMessageBuilder,
-  createCustomMessageBuilder,
-  createDefaultBuilders,
-} from './domain/index.js'
-
-export {
-  setZodErrorMap,
-  createZodErrorMap,
-} from './adapters/index.js'