@cosmicdrift/kumiko-headless 0.188.0 → 0.189.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-headless",
-  "version": "0.188.0",
+  "version": "0.189.0",
   "description": "Headless UI logic for Kumiko — Dispatcher contract, Form-Controller, View-Model, Nav-Resolver. Plattform- und React-frei; jeder Renderer (renderer, renderer-web, renderer-native, …) komponiert darauf.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -36,7 +36,7 @@
     }
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-framework": "0.188.0",
+    "@cosmicdrift/kumiko-framework": "0.189.0",
     "temporal-polyfill": "^0.3.2",
     "zod": "^4.4.3"
   },

package/src/form/__tests__/validation.test.ts

@@ -45,6 +45,45 @@ describe("zodErrorToFieldIssues", () => {
     expect(issues[0]?.params).toBeDefined();
     expect(issues[0]?.params?.["minimum"]).toBe(10);
   });
+
+  // kumiko-framework#1927: a bare `code:"custom"` issue (superRefine's only
+  // code) would otherwise always resolve to the generic "Invalid value."
+  // key — `params.i18nKey` lets a check like form-schema.ts's presence
+  // check point at its own key instead.
+  test("custom issue with params.i18nKey overrides the mechanical errors.validation.custom key", () => {
+    const schema = z.object({ name: z.string() }).superRefine((values, ctx) => {
+      if (values.name === "") {
+        ctx.addIssue({
+          code: "custom",
+          path: ["name"],
+          message: '"name" is required.',
+          params: { i18nKey: "kumiko.validation.required" },
+        });
+      }
+    });
+    const result = schema.safeParse({ name: "" });
+
+    expect(result.success).toBe(false);
+    if (result.success) return;
+    const issues = zodErrorToFieldIssues(result.error);
+
+    expect(issues[0]?.i18nKey).toBe("kumiko.validation.required");
+  });
+
+  test("custom issue without params.i18nKey still falls back to errors.validation.custom", () => {
+    const schema = z.object({ name: z.string() }).superRefine((values, ctx) => {
+      if (values.name === "bad") {
+        ctx.addIssue({ code: "custom", path: ["name"], message: "not allowed" });
+      }
+    });
+    const result = schema.safeParse({ name: "bad" });
+
+    expect(result.success).toBe(false);
+    if (result.success) return;
+    const issues = zodErrorToFieldIssues(result.error);
+
+    expect(issues[0]?.i18nKey).toBe("errors.validation.custom");
+  });
 });
 
 describe("groupIssuesByPath", () => {

package/src/form/zod-bridge.ts

@@ -43,12 +43,30 @@ export function zodErrorToFieldIssues(error: ZodError): FieldIssue[] {
       // malformed" errors under — matches what the server does.
       path: issue.path.map(String).join(".") || "(root)",
       code: issue.code,
-      i18nKey: `errors.validation.${issue.code}`,
+      i18nKey: resolveI18nKey(issue),
       ...(params && { params }),
     };
   });
 }
 
+// Every zod code maps mechanically to `errors.validation.<code>` — except
+// `code: "custom"`, which is zod's one-size-fits-all bucket for every
+// `superRefine`/`refine` check in the codebase. Left mechanical, ALL of them
+// would collapse onto the same `errors.validation.custom` ("Invalid
+// value.") key, which is wrong for a check that has a more specific message
+// (e.g. form-schema.ts's presence check wants "Pflichtfeld." / "Required.").
+// A `superRefine` that needs its own key sets `params.i18nKey` on the issue;
+// this is the one place that honors it. Keep in sync with the server-side
+// mirror (packages/framework/src/errors/zod-bridge.ts) — a superRefine can
+// run on either side.
+function resolveI18nKey(issue: ZodIssue): string {
+  if (issue.code === "custom") {
+    const override = issue.params?.["i18nKey"];
+    if (typeof override === "string") return override;
+  }
+  return `errors.validation.${issue.code}`;
+}
+
 function extractIssueParams(issue: ZodIssue): Readonly<Record<string, unknown>> | undefined {
   const out: Record<string, unknown> = {};
   const bag = issue as unknown as Record<string, unknown>; // @cast-boundary zod-issue

package/src/view-model/edit.ts

@@ -102,7 +102,7 @@ export function computeEditViewModel<
       // List-Builder), damit Form-Selects und List-Cells dieselbe
       // i18n-Quelle teilen.
       const options =
-        fieldDef.type === "select"
+        fieldDef.type === "select" || fieldDef.type === "multiSelect"
           ? ((fieldDef as unknown as { options?: readonly string[] }).options ?? [])
           : undefined;
       const optionLabels =
@@ -113,11 +113,12 @@ export function computeEditViewModel<
               options,
             )
           : undefined;
-      // Multiline-Hint bei `type: "text"` — der Renderer wechselt
-      // dann auf textarea. ViewModel hält die Form-Render-Decision
-      // damit der Renderer nicht selbst auf die FieldDefinition greift.
+      // Multiline hint for `type: "text"` — the renderer then switches to a
+      // textarea. `type: "longText"` always renders a textarea regardless
+      // of this hint; it's only carried through as an optional `{ rows }`
+      // override (#1925).
       const multiline =
-        fieldDef.type === "text"
+        fieldDef.type === "text" || fieldDef.type === "longText"
           ? (fieldDef as unknown as { multiline?: boolean | { rows?: number } }).multiline
           : undefined;
       // Wall-Clock-Hint bei `type: "timestamp"` mit locatedBy — der

package/src/view-model/types.ts

@@ -128,18 +128,22 @@ export type EditFieldViewModel = {
   readonly required: boolean;
   readonly span?: number;
   readonly renderer?: FieldRenderer;
-  /** Nur bei `type: "select"` gesetzt — die zugelassenen Werte. Wird
-   *  vom Renderer als Dropdown-Optionen genutzt. Quelle ist
-   *  SelectFieldDef.options aus der EntityDefinition. */
+  /** Set for `type: "select"` and `type: "multiSelect"` — the allowed
+   *  values. The renderer uses these as dropdown/combobox options.
+   *  Source is SelectFieldDef.options / MultiSelectFieldDef.options on
+   *  the EntityDefinition. */
   readonly options?: readonly string[];
-  /** Nur bei `type: "select"` gesetzt — translated Labels pro Option,
-   *  keyed nach raw value. Renderer zeigt `optionLabels[value]` als
-   *  Dropdown-Label statt raw value. Convention-Key:
+  /** Set for `type: "select"` and `type: "multiSelect"` — translated
+   *  labels per option, keyed by raw value. The renderer shows
+   *  `optionLabels[value]` as the dropdown/combobox label instead of the
+   *  raw value. Convention key:
    *  `<feature>:entity:<entity>:field:<field>:option:<value>`. */
   readonly optionLabels?: Readonly<Record<string, string>>;
-  /** Nur bei `type: "text"` gesetzt wenn TextFieldDef.multiline true
-   *  ist — dann rendert der Renderer textarea statt single-line input.
-   *  `true` = Default-Zeilen, `{ rows }` = explizite Höhe. */
+  /** For `type: "text"`, set when TextFieldDef.multiline is true — the
+   *  renderer then renders a textarea instead of a single-line input.
+   *  `type: "longText"` always renders a textarea regardless of this
+   *  value; here it only carries an optional `{ rows }` override.
+   *  `true` = default rows, `{ rows }` = explicit height. */
   readonly multiline?: boolean | { readonly rows?: number };
   /** Nur bei `type: "timestamp"` gesetzt wenn TimestampFieldDef.locatedBy
    *  existiert — Wall-Clock-Zeit ohne Offset. Der Renderer emittiert