@logixjs/form 0.0.1

package/dist/SchemaErrorMapping.cjs

@@ -0,0 +1,305 @@
+"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/SchemaErrorMapping.ts
+var SchemaErrorMapping_exports = {};
+__export(SchemaErrorMapping_exports, {
+  SchemaErrorMapping: () => SchemaErrorMapping,
+  applySchemaErrorToState: () => applySchemaErrorToState,
+  toSchemaErrorTree: () => toSchemaErrorTree,
+  toSchemaErrorWrites: () => toSchemaErrorWrites
+});
+module.exports = __toCommonJS(SchemaErrorMapping_exports);
+
+// src/internal/schema/SchemaPathMapping.ts
+var isNumericSegment = (seg) => /^[0-9]+$/.test(seg);
+var parseSegmentsFromString = (path) => {
+  if (!path) return [];
+  return path.split(".").filter(Boolean).map((seg) => isNumericSegment(seg) ? Number(seg) : seg);
+};
+var asSegments = (value) => {
+  if (typeof value === "string") return parseSegmentsFromString(value);
+  if (Array.isArray(value)) {
+    const parts = [];
+    for (const x of value) {
+      if (typeof x === "number" && Number.isFinite(x)) {
+        parts.push(Math.floor(x));
+        continue;
+      }
+      if (typeof x === "string" && x.length > 0) {
+        parts.push(isNumericSegment(x) ? Number(x) : x);
+      }
+    }
+    return parts.length ? parts : void 0;
+  }
+  return void 0;
+};
+var toConcretePath = (segments) => segments.map(String).join(".");
+var toPatternPath = (segments) => {
+  const out = [];
+  const indices = [];
+  for (const seg of segments) {
+    if (typeof seg === "number") {
+      out.push("[]");
+      indices.push(seg);
+    } else {
+      out.push(seg);
+    }
+  }
+  const pattern = out.join(".").replace(/\.\[\]/g, "[]");
+  return { pattern, indices };
+};
+var applyIndicesToPattern = (pattern, indices) => {
+  if (!pattern) return pattern;
+  const raw = pattern.split(".").filter(Boolean);
+  const out = [];
+  let cursor = 0;
+  for (const part of raw) {
+    if (part === "[]") {
+      const idx = indices[cursor++];
+      if (idx === void 0) return void 0;
+      out.push(String(idx));
+      continue;
+    }
+    if (part.endsWith("[]") && part.length > 2) {
+      const base = part.slice(0, -2);
+      out.push(base);
+      const idx = indices[cursor++];
+      if (idx === void 0) return void 0;
+      out.push(String(idx));
+      continue;
+    }
+    out.push(part);
+  }
+  return out.join(".");
+};
+var concatPaths = (prefix, rest) => {
+  if (!prefix) return rest;
+  if (!rest) return prefix;
+  return `${prefix}.${rest}`;
+};
+var mapByRename = (segments, rename) => {
+  const concrete = toConcretePath(segments);
+  const direct = rename[concrete];
+  if (direct !== void 0) {
+    return direct;
+  }
+  const { pattern, indices } = toPatternPath(segments);
+  const patternDirect = rename[pattern];
+  if (patternDirect !== void 0) {
+    return applyIndicesToPattern(patternDirect, indices);
+  }
+  const keys = Object.keys(rename).sort((a, b) => b.length - a.length);
+  for (const from of keys) {
+    const to = rename[from];
+    const isPattern = from.includes("[]");
+    const target = isPattern ? pattern : concrete;
+    if (target === from || target.startsWith(`${from}.`)) {
+      const rawRest = target.slice(from.length);
+      const rest = rawRest.startsWith(".") ? rawRest.slice(1) : rawRest;
+      const mapped = concatPaths(to, rest);
+      return isPattern ? applyIndicesToPattern(mapped, indices) : mapped;
+    }
+  }
+  const segMap = {};
+  for (const [from, to] of Object.entries(rename)) {
+    if (from.includes(".") || from.includes("[]")) continue;
+    if (to.includes(".") || to.includes("[]")) continue;
+    if (!to) continue;
+    segMap[from] = to;
+  }
+  if (Object.keys(segMap).length === 0) return void 0;
+  const mappedSegments = segments.map((seg) => typeof seg === "string" ? segMap[seg] ?? seg : seg);
+  return toConcretePath(mappedSegments);
+};
+var extractRawPaths = (schemaError) => {
+  const out = [];
+  if (schemaError && typeof schemaError === "object") {
+    const anyErr = schemaError;
+    if (Array.isArray(anyErr.errors)) {
+      for (const e of anyErr.errors) {
+        if (e && typeof e === "object" && "path" in e) {
+          out.push(e.path);
+        }
+      }
+    }
+    if (Array.isArray(anyErr.issues)) {
+      for (const e of anyErr.issues) {
+        if (e && typeof e === "object" && "path" in e) {
+          out.push(e.path);
+        }
+      }
+    }
+    if ("path" in anyErr) {
+      out.push(anyErr.path);
+    }
+  }
+  return out;
+};
+var mapSchemaErrorToFieldPaths = (schemaError, options) => {
+  const fromEscapeHatch = options?.errorMap?.(schemaError);
+  if (fromEscapeHatch && fromEscapeHatch.length) {
+    return Array.from(new Set(fromEscapeHatch.filter((p) => typeof p === "string" && p.length > 0)));
+  }
+  const rename = options?.rename;
+  const results = [];
+  for (const rawPath of extractRawPaths(schemaError)) {
+    const segments = asSegments(rawPath);
+    if (!segments || segments.length === 0) continue;
+    const mapped = rename ? mapByRename(segments, rename) : void 0;
+    const path = mapped ?? toConcretePath(segments);
+    if (path) results.push(path);
+  }
+  return Array.from(new Set(results));
+};
+
+// src/internal/form/path.ts
+var cloneContainer = (value) => {
+  if (Array.isArray(value)) return value.slice();
+  if (value && typeof value === "object") return { ...value };
+  return void 0;
+};
+var setAtPath = (state, path, value) => {
+  if (!path) return value;
+  const segments = path.split(".");
+  const rootClone = cloneContainer(state) ?? {};
+  let current = rootClone;
+  let currentSource = state;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const segment = segments[i];
+    const index = Number(segment);
+    const isIndex = Number.isInteger(index) && String(index) === segment;
+    const nextSource = currentSource == null ? void 0 : isIndex && Array.isArray(currentSource) ? currentSource[index] : currentSource[segment];
+    const nextSegment = segments[i + 1];
+    const nextIndex = Number(nextSegment);
+    const nextIsIndex = Number.isInteger(nextIndex) && String(nextIndex) === nextSegment;
+    const nextClone = cloneContainer(nextSource) ?? (nextIsIndex ? [] : {});
+    if (isIndex && Array.isArray(current)) {
+      current[index] = nextClone;
+    } else {
+      current[segment] = nextClone;
+    }
+    current = nextClone;
+    currentSource = nextSource;
+  }
+  const last = segments[segments.length - 1];
+  const lastIndex = Number(last);
+  const lastIsIndex = Number.isInteger(lastIndex) && String(lastIndex) === last;
+  if (lastIsIndex && Array.isArray(current)) {
+    current[lastIndex] = value;
+  } else {
+    current[last] = value;
+  }
+  return rootClone;
+};
+
+// src/Path.ts
+var isNumericSegment2 = (seg) => /^[0-9]+$/.test(seg);
+var splitPath = (path) => {
+  if (!path) return [];
+  const parts = path.split(".").filter((p) => p.length > 0);
+  const segs = [];
+  for (const part of parts) {
+    if (!part) continue;
+    if (part.endsWith("[]")) {
+      const base = part.slice(0, -2);
+      if (base) segs.push(base);
+      segs.push("[]");
+      continue;
+    }
+    const bracket = /^(.+)\[(\d+)\]$/.exec(part);
+    if (bracket) {
+      const base = bracket[1];
+      if (base) segs.push(base);
+      segs.push(bracket[2]);
+      continue;
+    }
+    segs.push(part);
+  }
+  return segs;
+};
+var toErrorsPath = (valuePath) => {
+  if (!valuePath) return "errors";
+  const segs = splitPath(valuePath);
+  const out = [];
+  for (const seg of segs) {
+    if (isNumericSegment2(seg)) {
+      out.push("rows", seg);
+      continue;
+    }
+    if (seg === "[]") {
+      continue;
+    }
+    out.push(seg);
+  }
+  return `errors.${out.join(".")}`;
+};
+var toSchemaErrorsPath = (valuePath) => {
+  const base = toErrorsPath(valuePath);
+  return base === "errors" ? "errors.$schema" : base.replace(/^errors\./, "errors.$schema.");
+};
+
+// src/internal/schema/SchemaErrorMapping.ts
+var toSchemaErrorWrites = (schemaError, options) => {
+  const fieldPaths = mapSchemaErrorToFieldPaths(schemaError, options);
+  if (fieldPaths.length === 0) return [];
+  const toLeaf = options?.toLeaf ?? ((e) => e);
+  const leaf = toLeaf(schemaError);
+  return fieldPaths.map((fieldPath) => ({
+    fieldPath,
+    errorPath: toSchemaErrorsPath(fieldPath),
+    error: leaf
+  }));
+};
+var toSchemaErrorTree = (schemaError, options) => {
+  const writes = toSchemaErrorWrites(schemaError, options);
+  if (writes.length === 0) return {};
+  let next = {};
+  for (const w of writes) {
+    const prefix = "errors.$schema.";
+    const relative = w.errorPath.startsWith(prefix) ? w.errorPath.slice(prefix.length) : w.errorPath;
+    if (!relative) continue;
+    next = setAtPath(next, relative, w.error);
+  }
+  return next;
+};
+var applySchemaErrorToState = (state, schemaError, options) => {
+  const writes = toSchemaErrorWrites(schemaError, options);
+  if (writes.length === 0) return state;
+  let next = state;
+  for (const w of writes) {
+    next = setAtPath(next, w.errorPath, w.error);
+  }
+  return next;
+};
+
+// src/SchemaErrorMapping.ts
+var SchemaErrorMapping = {
+  applySchemaErrorToState,
+  toSchemaErrorTree,
+  toSchemaErrorWrites
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SchemaErrorMapping,
+  applySchemaErrorToState,
+  toSchemaErrorTree,
+  toSchemaErrorWrites
+});
+//# sourceMappingURL=SchemaErrorMapping.cjs.map

package/dist/SchemaErrorMapping.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/SchemaErrorMapping.ts","../src/internal/schema/SchemaPathMapping.ts","../src/internal/form/path.ts","../src/Path.ts","../src/internal/schema/SchemaErrorMapping.ts"],"sourcesContent":["import {\n  applySchemaErrorToState,\n  toSchemaErrorTree,\n  toSchemaErrorWrites,\n} from './internal/schema/SchemaErrorMapping.js'\n\nexport type { SchemaErrorMappingOptions, SchemaErrorWrite } from './internal/schema/SchemaErrorMapping.js'\n\nexport { applySchemaErrorToState, toSchemaErrorTree, toSchemaErrorWrites }\n\nexport const SchemaErrorMapping = {\n  applySchemaErrorToState,\n  toSchemaErrorTree,\n  toSchemaErrorWrites,\n} as const\n","export type FieldPath = string\n\nexport type SchemaError = unknown\n\nexport interface SchemaPathMappingOptions {\n  /**\n   * errorMap: an escape hatch for complex transform cases (explicitly assigns an error to a set of field paths).\n   */\n  readonly errorMap?: (schemaError: SchemaError) => ReadonlyArray<FieldPath>\n  /**\n   * rename: a common rename mapping (domainPath -> viewPath).\n   */\n  readonly rename?: Readonly<Record<FieldPath, FieldPath>>\n}\n\ntype Segment = string | number\n\nconst isNumericSegment = (seg: string): boolean => /^[0-9]+$/.test(seg)\n\nconst parseSegmentsFromString = (path: string): ReadonlyArray<Segment> => {\n  if (!path) return []\n  return path\n    .split('.')\n    .filter(Boolean)\n    .map((seg) => (isNumericSegment(seg) ? Number(seg) : seg))\n}\n\nconst asSegments = (value: unknown): ReadonlyArray<Segment> | undefined => {\n  if (typeof value === 'string') return parseSegmentsFromString(value)\n  if (Array.isArray(value)) {\n    const parts: Array<Segment> = []\n    for (const x of value) {\n      if (typeof x === 'number' && Number.isFinite(x)) {\n        parts.push(Math.floor(x))\n        continue\n      }\n      if (typeof x === 'string' && x.length > 0) {\n        parts.push(isNumericSegment(x) ? Number(x) : x)\n      }\n    }\n    return parts.length ? parts : undefined\n  }\n  return undefined\n}\n\nconst toConcretePath = (segments: ReadonlyArray<Segment>): string => segments.map(String).join('.')\n\nconst toPatternPath = (\n  segments: ReadonlyArray<Segment>,\n): { readonly pattern: string; readonly indices: ReadonlyArray<number> } => {\n  const out: Array<string> = []\n  const indices: Array<number> = []\n  for (const seg of segments) {\n    if (typeof seg === 'number') {\n      out.push('[]')\n      indices.push(seg)\n    } else {\n      out.push(seg)\n    }\n  }\n  const pattern = out.join('.').replace(/\\.\\[\\]/g, '[]')\n  return { pattern, indices }\n}\n\nconst applyIndicesToPattern = (pattern: string, indices: ReadonlyArray<number>): string | undefined => {\n  if (!pattern) return pattern\n  const raw = pattern.split('.').filter(Boolean)\n  const out: Array<string> = []\n\n  let cursor = 0\n  for (const part of raw) {\n    if (part === '[]') {\n      const idx = indices[cursor++]\n      if (idx === undefined) return undefined\n      out.push(String(idx))\n      continue\n    }\n    if (part.endsWith('[]') && part.length > 2) {\n      const base = part.slice(0, -2)\n      out.push(base)\n      const idx = indices[cursor++]\n      if (idx === undefined) return undefined\n      out.push(String(idx))\n      continue\n    }\n    out.push(part)\n  }\n  return out.join('.')\n}\n\nconst concatPaths = (prefix: string, rest: string): string => {\n  if (!prefix) return rest\n  if (!rest) return prefix\n  return `${prefix}.${rest}`\n}\n\nconst mapByRename = (\n  segments: ReadonlyArray<Segment>,\n  rename: Readonly<Record<FieldPath, FieldPath>>,\n): string | undefined => {\n  const concrete = toConcretePath(segments)\n  const direct = rename[concrete]\n  if (direct !== undefined) {\n    return direct\n  }\n\n  const { pattern, indices } = toPatternPath(segments)\n  const patternDirect = rename[pattern]\n  if (patternDirect !== undefined) {\n    return applyIndicesToPattern(patternDirect, indices)\n  }\n\n  const keys = Object.keys(rename).sort((a, b) => b.length - a.length)\n  for (const from of keys) {\n    const to = rename[from]!\n\n    const isPattern = from.includes('[]')\n    const target = isPattern ? pattern : concrete\n\n    if (target === from || target.startsWith(`${from}.`)) {\n      const rawRest = target.slice(from.length)\n      const rest = rawRest.startsWith('.') ? rawRest.slice(1) : rawRest\n      const mapped = concatPaths(to, rest)\n      return isPattern ? applyIndicesToPattern(mapped, indices) : mapped\n    }\n  }\n\n  // Segment-level rename: only enabled when both from/to are single segments, to avoid accidental \"path rewrites\".\n  const segMap: Record<string, string> = {}\n  for (const [from, to] of Object.entries(rename)) {\n    if (from.includes('.') || from.includes('[]')) continue\n    if (to.includes('.') || to.includes('[]')) continue\n    if (!to) continue\n    segMap[from] = to\n  }\n  if (Object.keys(segMap).length === 0) return undefined\n\n  const mappedSegments = segments.map((seg) => (typeof seg === 'string' ? (segMap[seg] ?? seg) : seg))\n  return toConcretePath(mappedSegments)\n}\n\nconst extractRawPaths = (schemaError: SchemaError): ReadonlyArray<unknown> => {\n  const out: Array<unknown> = []\n\n  if (schemaError && typeof schemaError === 'object') {\n    const anyErr = schemaError as any\n    if (Array.isArray(anyErr.errors)) {\n      for (const e of anyErr.errors) {\n        if (e && typeof e === 'object' && 'path' in (e as any)) {\n          out.push((e as any).path)\n        }\n      }\n    }\n    if (Array.isArray(anyErr.issues)) {\n      for (const e of anyErr.issues) {\n        if (e && typeof e === 'object' && 'path' in (e as any)) {\n          out.push((e as any).path)\n        }\n      }\n    }\n    if ('path' in anyErr) {\n      out.push(anyErr.path)\n    }\n  }\n\n  return out\n}\n\n/**\n * mapSchemaErrorToFieldPaths：\n * - Phase 3: provides a minimal, usable default mapping, and allows `errorMap` to override.\n * - In a later phase (US3), we will raise the coverage goal to \">= 80% common mappings\" and fill the test matrix.\n */\nexport const mapSchemaErrorToFieldPaths = (\n  schemaError: SchemaError,\n  options?: SchemaPathMappingOptions,\n): ReadonlyArray<FieldPath> => {\n  const fromEscapeHatch = options?.errorMap?.(schemaError)\n  if (fromEscapeHatch && fromEscapeHatch.length) {\n    return Array.from(new Set(fromEscapeHatch.filter((p) => typeof p === 'string' && p.length > 0)))\n  }\n\n  const rename = options?.rename\n  const results: Array<string> = []\n\n  for (const rawPath of extractRawPaths(schemaError)) {\n    const segments = asSegments(rawPath)\n    if (!segments || segments.length === 0) continue\n\n    const mapped = rename ? mapByRename(segments, rename) : undefined\n\n    const path = mapped ?? toConcretePath(segments)\n    if (path) results.push(path)\n  }\n\n  return Array.from(new Set(results))\n}\n","export const getAtPath = (state: unknown, path: string): unknown => {\n  if (!path) return state\n\n  const segments = path.split('.')\n  let current: any = state\n\n  for (const segment of segments) {\n    if (current == null) return undefined\n    const index = Number(segment)\n    if (Array.isArray(current) && Number.isInteger(index) && String(index) === segment) {\n      current = current[index]\n      continue\n    }\n    current = current[segment]\n  }\n\n  return current\n}\n\nconst cloneContainer = (value: unknown): any => {\n  if (Array.isArray(value)) return value.slice()\n  if (value && typeof value === 'object') return { ...(value as any) }\n  return undefined\n}\n\nexport const setAtPath = (state: unknown, path: string, value: unknown): unknown => {\n  if (!path) return value\n\n  const segments = path.split('.')\n  const rootClone = cloneContainer(state) ?? {}\n\n  let current: any = rootClone\n  let currentSource: any = state\n\n  for (let i = 0; i < segments.length - 1; i++) {\n    const segment = segments[i]!\n    const index = Number(segment)\n    const isIndex = Number.isInteger(index) && String(index) === segment\n\n    const nextSource =\n      currentSource == null\n        ? undefined\n        : isIndex && Array.isArray(currentSource)\n          ? currentSource[index]\n          : currentSource[segment]\n\n    const nextSegment = segments[i + 1]!\n    const nextIndex = Number(nextSegment)\n    const nextIsIndex = Number.isInteger(nextIndex) && String(nextIndex) === nextSegment\n\n    const nextClone = cloneContainer(nextSource) ?? (nextIsIndex ? [] : {})\n\n    if (isIndex && Array.isArray(current)) {\n      current[index] = nextClone\n    } else {\n      current[segment] = nextClone\n    }\n\n    current = nextClone\n    currentSource = nextSource\n  }\n\n  const last = segments[segments.length - 1]!\n  const lastIndex = Number(last)\n  const lastIsIndex = Number.isInteger(lastIndex) && String(lastIndex) === last\n\n  if (lastIsIndex && Array.isArray(current)) {\n    current[lastIndex] = value\n  } else {\n    current[last] = value\n  }\n\n  return rootClone\n}\n\nexport const unsetAtPath = (state: unknown, path: string): unknown => {\n  if (!path) return state\n  if (getAtPath(state, path) === undefined) return state\n\n  const segments = path.split('.')\n  const rootClone = cloneContainer(state)\n  if (rootClone === undefined) return state\n\n  let current: any = rootClone\n  let currentSource: any = state\n\n  for (let i = 0; i < segments.length - 1; i++) {\n    const segment = segments[i]!\n    const index = Number(segment)\n    const isIndex = Number.isInteger(index) && String(index) === segment\n\n    const nextSource =\n      currentSource == null\n        ? undefined\n        : isIndex && Array.isArray(currentSource)\n          ? currentSource[index]\n          : currentSource[segment]\n\n    const nextClone = cloneContainer(nextSource)\n    if (nextClone === undefined) {\n      return state\n    }\n\n    if (isIndex && Array.isArray(current)) {\n      current[index] = nextClone\n    } else {\n      current[segment] = nextClone\n    }\n\n    current = nextClone\n    currentSource = nextSource\n  }\n\n  const last = segments[segments.length - 1]!\n  const lastIndex = Number(last)\n  const lastIsIndex = Number.isInteger(lastIndex) && String(lastIndex) === last\n\n  if (lastIsIndex && Array.isArray(current)) {\n    current[lastIndex] = undefined\n    return rootClone\n  }\n\n  if (current && typeof current === 'object') {\n    delete current[last]\n  }\n\n  return rootClone\n}\n\nexport const updateArrayAtPath = (\n  state: unknown,\n  path: string,\n  update: (items: ReadonlyArray<unknown>) => ReadonlyArray<unknown>,\n): unknown => {\n  const current = getAtPath(state, path)\n  const items = Array.isArray(current) ? current : []\n  const next = update(items)\n  return setAtPath(state, path, next)\n}\n","export type ValuePath = string\nexport type PatternPath = string\nexport type ListPath = string\nexport type ErrorsPath = string\nexport type UiPath = string\nexport type FieldPath = ReadonlyArray<string>\n\nconst isNumericSegment = (seg: string): boolean => /^[0-9]+$/.test(seg)\n\nconst splitPath = (path: string): ReadonlyArray<string> => {\n  if (!path) return []\n  const parts = path.split('.').filter((p) => p.length > 0)\n  const segs: Array<string> = []\n\n  for (const part of parts) {\n    if (!part) continue\n    if (part.endsWith('[]')) {\n      const base = part.slice(0, -2)\n      if (base) segs.push(base)\n      segs.push('[]')\n      continue\n    }\n    const bracket = /^(.+)\\[(\\d+)\\]$/.exec(part)\n    if (bracket) {\n      const base = bracket[1]!\n      if (base) segs.push(base)\n      segs.push(bracket[2]!)\n      continue\n    }\n    segs.push(part)\n  }\n\n  return segs\n}\n\nexport const toPatternPath = (valuePath: ValuePath): PatternPath => {\n  if (!valuePath) return valuePath\n  const segs = splitPath(valuePath)\n  const out: Array<string> = []\n\n  for (const seg of segs) {\n    if (seg === '[]' || isNumericSegment(seg)) {\n      if (out.length === 0) continue\n      const last = out[out.length - 1]!\n      if (!last.endsWith('[]')) out[out.length - 1] = `${last}[]`\n      continue\n    }\n    out.push(seg)\n  }\n\n  return out.join('.')\n}\n\nexport const toListPath = (valuePath: ValuePath): ListPath | undefined => {\n  const segs = splitPath(valuePath)\n  const firstIndex = segs.findIndex((seg) => seg === '[]' || isNumericSegment(seg))\n  if (firstIndex <= 0) return undefined\n  return segs.slice(0, firstIndex).join('.')\n}\n\nexport const toErrorsPath = (valuePath: ValuePath): ErrorsPath => {\n  if (!valuePath) return 'errors'\n  const segs = splitPath(valuePath)\n  const out: Array<string> = []\n\n  for (const seg of segs) {\n    if (isNumericSegment(seg)) {\n      out.push('rows', seg)\n      continue\n    }\n    if (seg === '[]') {\n      continue\n    }\n    out.push(seg)\n  }\n\n  return `errors.${out.join('.')}`\n}\n\nexport const toManualErrorsPath = (valuePath: ValuePath): ErrorsPath => {\n  const base = toErrorsPath(valuePath)\n  return base === 'errors' ? 'errors.$manual' : base.replace(/^errors\\./, 'errors.$manual.')\n}\n\nexport const toSchemaErrorsPath = (valuePath: ValuePath): ErrorsPath => {\n  const base = toErrorsPath(valuePath)\n  return base === 'errors' ? 'errors.$schema' : base.replace(/^errors\\./, 'errors.$schema.')\n}\n\nexport const toUiPath = (valuePath: ValuePath): UiPath => (valuePath ? `ui.${valuePath}` : 'ui')\n\nexport const toFieldPath = (path: ValuePath | PatternPath): FieldPath => {\n  const segs = splitPath(path)\n  const out: Array<string> = []\n  for (const seg of segs) {\n    if (seg === '[]' || isNumericSegment(seg)) continue\n    out.push(seg)\n  }\n  return out.length > 0 ? out : ['$root']\n}\n\nexport const Path = {\n  toPatternPath,\n  toListPath,\n  toErrorsPath,\n  toManualErrorsPath,\n  toSchemaErrorsPath,\n  toUiPath,\n  toFieldPath,\n} as const\n","import type { FieldPath, SchemaError, SchemaPathMappingOptions } from './SchemaPathMapping.js'\nimport { mapSchemaErrorToFieldPaths } from './SchemaPathMapping.js'\nimport { setAtPath } from '../form/path.js'\nimport { toSchemaErrorsPath } from '../../Path.js'\n\nexport interface SchemaErrorMappingOptions extends SchemaPathMappingOptions {\n  /**\n   * toLeaf: converts a schemaError into a leaf value that can be written into the error tree.\n   * - Default: write the raw schemaError as-is.\n   */\n  readonly toLeaf?: (schemaError: SchemaError) => unknown\n}\n\nexport type SchemaErrorWrite = {\n  /**\n   * fieldPath: the field path without the `errors.` prefix (domain-facing).\n   */\n  readonly fieldPath: FieldPath\n  /**\n   * errorPath: the actual path written into state (with the `errors.` prefix).\n   */\n  readonly errorPath: string\n  readonly error: unknown\n}\n\nexport const toSchemaErrorWrites = (\n  schemaError: SchemaError,\n  options?: SchemaErrorMappingOptions,\n): ReadonlyArray<SchemaErrorWrite> => {\n  const fieldPaths = mapSchemaErrorToFieldPaths(schemaError, options)\n  if (fieldPaths.length === 0) return []\n\n  const toLeaf = options?.toLeaf ?? ((e: SchemaError) => e)\n  const leaf = toLeaf(schemaError)\n\n  return fieldPaths.map((fieldPath) => ({\n    fieldPath,\n    errorPath: toSchemaErrorsPath(fieldPath),\n    error: leaf,\n  }))\n}\n\n/**\n * toSchemaErrorTree：\n * - Produces a subtree that can be written directly to `errors.$schema` (without the `errors.$schema` prefix).\n */\nexport const toSchemaErrorTree = (schemaError: SchemaError, options?: SchemaErrorMappingOptions): unknown => {\n  const writes = toSchemaErrorWrites(schemaError, options)\n  if (writes.length === 0) return {}\n\n  let next: unknown = {}\n  for (const w of writes) {\n    const prefix = 'errors.$schema.'\n    const relative = w.errorPath.startsWith(prefix) ? w.errorPath.slice(prefix.length) : w.errorPath\n    if (!relative) continue\n    next = setAtPath(next, relative, w.error)\n  }\n  return next\n}\n\n/**\n * applySchemaErrorToState：\n * - Maps a SchemaError and writes it back into state.errors.$schema.*.\n * - Does not clear stale errors that are no longer matched (the caller should clear them within a more explicit scope).\n */\nexport const applySchemaErrorToState = (\n  state: unknown,\n  schemaError: SchemaError,\n  options?: SchemaErrorMappingOptions,\n): unknown => {\n  const writes = toSchemaErrorWrites(schemaError, options)\n  if (writes.length === 0) return state\n\n  let next: unknown = state\n  for (const w of writes) {\n    next = setAtPath(next, w.errorPath, w.error)\n  }\n  return next\n}\n"],"mappings":"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","names":["isNumericSegment","isNumericSegment"]}

package/dist/SchemaErrorMapping.d.cts

@@ -0,0 +1,2 @@
+export { c as SchemaErrorMapping, d as SchemaErrorMappingOptions, e as SchemaErrorWrite, a as applySchemaErrorToState, t as toSchemaErrorTree, b as toSchemaErrorWrites } from './SchemaErrorMapping-DOrgLzii.cjs';
+import './SchemaPathMapping-BUq2zm8W.cjs';

package/dist/SchemaErrorMapping.d.ts

@@ -0,0 +1,2 @@
+export { c as SchemaErrorMapping, d as SchemaErrorMappingOptions, e as SchemaErrorWrite, a as applySchemaErrorToState, t as toSchemaErrorTree, b as toSchemaErrorWrites } from './SchemaErrorMapping-Cu5gl7-Z.js';
+import './SchemaPathMapping-BUq2zm8W.js';

package/dist/SchemaErrorMapping.js

@@ -0,0 +1,17 @@
+import {
+  SchemaErrorMapping,
+  applySchemaErrorToState,
+  toSchemaErrorTree,
+  toSchemaErrorWrites
+} from "./chunk-JZ5FZKPJ.js";
+import "./chunk-5DRI5UGD.js";
+import "./chunk-OJVEZKU7.js";
+import "./chunk-EOXJRCM6.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  SchemaErrorMapping,
+  applySchemaErrorToState,
+  toSchemaErrorTree,
+  toSchemaErrorWrites
+};
+//# sourceMappingURL=SchemaErrorMapping.js.map

package/dist/SchemaErrorMapping.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/SchemaPathMapping-BCoUW-_q.d.ts

@@ -0,0 +1,16 @@
+import { S as SchemaError, a as SchemaPathMappingOptions, F as FieldPath, m as mapSchemaErrorToFieldPaths } from './SchemaPathMapping-BUq2zm8W.js';
+
+declare const SchemaPathMapping: {
+    readonly mapSchemaErrorToFieldPaths: (schemaError: SchemaError, options?: SchemaPathMappingOptions) => ReadonlyArray<FieldPath>;
+};
+
+declare const SchemaPathMapping$1_FieldPath: typeof FieldPath;
+declare const SchemaPathMapping$1_SchemaError: typeof SchemaError;
+declare const SchemaPathMapping$1_SchemaPathMapping: typeof SchemaPathMapping;
+declare const SchemaPathMapping$1_SchemaPathMappingOptions: typeof SchemaPathMappingOptions;
+declare const SchemaPathMapping$1_mapSchemaErrorToFieldPaths: typeof mapSchemaErrorToFieldPaths;
+declare namespace SchemaPathMapping$1 {
+  export { SchemaPathMapping$1_FieldPath as FieldPath, SchemaPathMapping$1_SchemaError as SchemaError, SchemaPathMapping$1_SchemaPathMapping as SchemaPathMapping, SchemaPathMapping$1_SchemaPathMappingOptions as SchemaPathMappingOptions, SchemaPathMapping$1_mapSchemaErrorToFieldPaths as mapSchemaErrorToFieldPaths };
+}
+
+export { SchemaPathMapping$1 as S, SchemaPathMapping as a };

package/dist/SchemaPathMapping-BUq2zm8W.d.cts

@@ -0,0 +1,20 @@
+type FieldPath = string;
+type SchemaError = unknown;
+interface SchemaPathMappingOptions {
+    /**
+     * errorMap: an escape hatch for complex transform cases (explicitly assigns an error to a set of field paths).
+     */
+    readonly errorMap?: (schemaError: SchemaError) => ReadonlyArray<FieldPath>;
+    /**
+     * rename: a common rename mapping (domainPath -> viewPath).
+     */
+    readonly rename?: Readonly<Record<FieldPath, FieldPath>>;
+}
+/**
+ * mapSchemaErrorToFieldPaths：
+ * - Phase 3: provides a minimal, usable default mapping, and allows `errorMap` to override.
+ * - In a later phase (US3), we will raise the coverage goal to ">= 80% common mappings" and fill the test matrix.
+ */
+declare const mapSchemaErrorToFieldPaths: (schemaError: SchemaError, options?: SchemaPathMappingOptions) => ReadonlyArray<FieldPath>;
+
+export { type FieldPath as F, type SchemaError as S, type SchemaPathMappingOptions as a, mapSchemaErrorToFieldPaths as m };

package/dist/SchemaPathMapping-BUq2zm8W.d.ts

@@ -0,0 +1,20 @@
+type FieldPath = string;
+type SchemaError = unknown;
+interface SchemaPathMappingOptions {
+    /**
+     * errorMap: an escape hatch for complex transform cases (explicitly assigns an error to a set of field paths).
+     */
+    readonly errorMap?: (schemaError: SchemaError) => ReadonlyArray<FieldPath>;
+    /**
+     * rename: a common rename mapping (domainPath -> viewPath).
+     */
+    readonly rename?: Readonly<Record<FieldPath, FieldPath>>;
+}
+/**
+ * mapSchemaErrorToFieldPaths：
+ * - Phase 3: provides a minimal, usable default mapping, and allows `errorMap` to override.
+ * - In a later phase (US3), we will raise the coverage goal to ">= 80% common mappings" and fill the test matrix.
+ */
+declare const mapSchemaErrorToFieldPaths: (schemaError: SchemaError, options?: SchemaPathMappingOptions) => ReadonlyArray<FieldPath>;
+
+export { type FieldPath as F, type SchemaError as S, type SchemaPathMappingOptions as a, mapSchemaErrorToFieldPaths as m };

package/dist/SchemaPathMapping-DJnExqM3.d.cts

@@ -0,0 +1,16 @@
+import { S as SchemaError, a as SchemaPathMappingOptions, F as FieldPath, m as mapSchemaErrorToFieldPaths } from './SchemaPathMapping-BUq2zm8W.cjs';
+
+declare const SchemaPathMapping: {
+    readonly mapSchemaErrorToFieldPaths: (schemaError: SchemaError, options?: SchemaPathMappingOptions) => ReadonlyArray<FieldPath>;
+};
+
+declare const SchemaPathMapping$1_FieldPath: typeof FieldPath;
+declare const SchemaPathMapping$1_SchemaError: typeof SchemaError;
+declare const SchemaPathMapping$1_SchemaPathMapping: typeof SchemaPathMapping;
+declare const SchemaPathMapping$1_SchemaPathMappingOptions: typeof SchemaPathMappingOptions;
+declare const SchemaPathMapping$1_mapSchemaErrorToFieldPaths: typeof mapSchemaErrorToFieldPaths;
+declare namespace SchemaPathMapping$1 {
+  export { SchemaPathMapping$1_FieldPath as FieldPath, SchemaPathMapping$1_SchemaError as SchemaError, SchemaPathMapping$1_SchemaPathMapping as SchemaPathMapping, SchemaPathMapping$1_SchemaPathMappingOptions as SchemaPathMappingOptions, SchemaPathMapping$1_mapSchemaErrorToFieldPaths as mapSchemaErrorToFieldPaths };
+}
+
+export { SchemaPathMapping$1 as S, SchemaPathMapping as a };

package/dist/SchemaPathMapping.cjs

@@ -0,0 +1,179 @@
+"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/SchemaPathMapping.ts
+var SchemaPathMapping_exports = {};
+__export(SchemaPathMapping_exports, {
+  SchemaPathMapping: () => SchemaPathMapping,
+  mapSchemaErrorToFieldPaths: () => mapSchemaErrorToFieldPaths
+});
+module.exports = __toCommonJS(SchemaPathMapping_exports);
+
+// src/internal/schema/SchemaPathMapping.ts
+var isNumericSegment = (seg) => /^[0-9]+$/.test(seg);
+var parseSegmentsFromString = (path) => {
+  if (!path) return [];
+  return path.split(".").filter(Boolean).map((seg) => isNumericSegment(seg) ? Number(seg) : seg);
+};
+var asSegments = (value) => {
+  if (typeof value === "string") return parseSegmentsFromString(value);
+  if (Array.isArray(value)) {
+    const parts = [];
+    for (const x of value) {
+      if (typeof x === "number" && Number.isFinite(x)) {
+        parts.push(Math.floor(x));
+        continue;
+      }
+      if (typeof x === "string" && x.length > 0) {
+        parts.push(isNumericSegment(x) ? Number(x) : x);
+      }
+    }
+    return parts.length ? parts : void 0;
+  }
+  return void 0;
+};
+var toConcretePath = (segments) => segments.map(String).join(".");
+var toPatternPath = (segments) => {
+  const out = [];
+  const indices = [];
+  for (const seg of segments) {
+    if (typeof seg === "number") {
+      out.push("[]");
+      indices.push(seg);
+    } else {
+      out.push(seg);
+    }
+  }
+  const pattern = out.join(".").replace(/\.\[\]/g, "[]");
+  return { pattern, indices };
+};
+var applyIndicesToPattern = (pattern, indices) => {
+  if (!pattern) return pattern;
+  const raw = pattern.split(".").filter(Boolean);
+  const out = [];
+  let cursor = 0;
+  for (const part of raw) {
+    if (part === "[]") {
+      const idx = indices[cursor++];
+      if (idx === void 0) return void 0;
+      out.push(String(idx));
+      continue;
+    }
+    if (part.endsWith("[]") && part.length > 2) {
+      const base = part.slice(0, -2);
+      out.push(base);
+      const idx = indices[cursor++];
+      if (idx === void 0) return void 0;
+      out.push(String(idx));
+      continue;
+    }
+    out.push(part);
+  }
+  return out.join(".");
+};
+var concatPaths = (prefix, rest) => {
+  if (!prefix) return rest;
+  if (!rest) return prefix;
+  return `${prefix}.${rest}`;
+};
+var mapByRename = (segments, rename) => {
+  const concrete = toConcretePath(segments);
+  const direct = rename[concrete];
+  if (direct !== void 0) {
+    return direct;
+  }
+  const { pattern, indices } = toPatternPath(segments);
+  const patternDirect = rename[pattern];
+  if (patternDirect !== void 0) {
+    return applyIndicesToPattern(patternDirect, indices);
+  }
+  const keys = Object.keys(rename).sort((a, b) => b.length - a.length);
+  for (const from of keys) {
+    const to = rename[from];
+    const isPattern = from.includes("[]");
+    const target = isPattern ? pattern : concrete;
+    if (target === from || target.startsWith(`${from}.`)) {
+      const rawRest = target.slice(from.length);
+      const rest = rawRest.startsWith(".") ? rawRest.slice(1) : rawRest;
+      const mapped = concatPaths(to, rest);
+      return isPattern ? applyIndicesToPattern(mapped, indices) : mapped;
+    }
+  }
+  const segMap = {};
+  for (const [from, to] of Object.entries(rename)) {
+    if (from.includes(".") || from.includes("[]")) continue;
+    if (to.includes(".") || to.includes("[]")) continue;
+    if (!to) continue;
+    segMap[from] = to;
+  }
+  if (Object.keys(segMap).length === 0) return void 0;
+  const mappedSegments = segments.map((seg) => typeof seg === "string" ? segMap[seg] ?? seg : seg);
+  return toConcretePath(mappedSegments);
+};
+var extractRawPaths = (schemaError) => {
+  const out = [];
+  if (schemaError && typeof schemaError === "object") {
+    const anyErr = schemaError;
+    if (Array.isArray(anyErr.errors)) {
+      for (const e of anyErr.errors) {
+        if (e && typeof e === "object" && "path" in e) {
+          out.push(e.path);
+        }
+      }
+    }
+    if (Array.isArray(anyErr.issues)) {
+      for (const e of anyErr.issues) {
+        if (e && typeof e === "object" && "path" in e) {
+          out.push(e.path);
+        }
+      }
+    }
+    if ("path" in anyErr) {
+      out.push(anyErr.path);
+    }
+  }
+  return out;
+};
+var mapSchemaErrorToFieldPaths = (schemaError, options) => {
+  const fromEscapeHatch = options?.errorMap?.(schemaError);
+  if (fromEscapeHatch && fromEscapeHatch.length) {
+    return Array.from(new Set(fromEscapeHatch.filter((p) => typeof p === "string" && p.length > 0)));
+  }
+  const rename = options?.rename;
+  const results = [];
+  for (const rawPath of extractRawPaths(schemaError)) {
+    const segments = asSegments(rawPath);
+    if (!segments || segments.length === 0) continue;
+    const mapped = rename ? mapByRename(segments, rename) : void 0;
+    const path = mapped ?? toConcretePath(segments);
+    if (path) results.push(path);
+  }
+  return Array.from(new Set(results));
+};
+
+// src/SchemaPathMapping.ts
+var SchemaPathMapping = {
+  mapSchemaErrorToFieldPaths
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SchemaPathMapping,
+  mapSchemaErrorToFieldPaths
+});
+//# sourceMappingURL=SchemaPathMapping.cjs.map