@cosmicdrift/kumiko-renderer 0.193.1 → 0.195.0

package/src/components/__tests__/render-field-money-roundtrip.test.tsx

@@ -21,6 +21,7 @@ import type {
 import { computeEditViewModel, type EditFieldViewModel } from "@cosmicdrift/kumiko-headless";
 import { render } from "@testing-library/react";
 import type { ComponentType, ReactNode } from "react";
+import { buildInitialValues } from "../../app/kumiko-screen";
 import { createStaticLocaleResolver, LocaleProvider } from "../../i18n";
 import { type CorePrimitives, type InputProps, PrimitivesProvider } from "../../primitives";
 import { RenderField } from "../render-field";
@@ -116,6 +117,19 @@ describe("RenderField money round-trip (kumiko-framework#1923)", () => {
     expect(result.success).toBe(true);
   });
 
+  test("create: buildInitialValues default renders as 0.00 in the widget, not empty", () => {
+    // Regression: the widget was tested with `values: {}` (no field.value at
+    // all), which produces "" — but the real entityEdit create path always
+    // feeds buildInitialValues(fields, defaultCurrency), which yields
+    // {amount: 0, currency} (kumiko-screen.tsx buildInitialValues).
+    const entity = buildEntity("USD");
+    const initialValues = buildInitialValues(entity.fields, "USD");
+    const field = renderMoneyField(entity, initialValues, () => {});
+    expect(field.kind).toBe("money");
+    if (field.kind !== "money") return;
+    expect(field.value).toBe(0);
+  });
+
   test("create: user-entered amount becomes a payload that validates against buildInsertSchema", () => {
     const entity = buildEntity("USD");
     let payload: unknown;

package/src/components/__tests__/render-field-unsupported-types.test.tsx

@@ -98,11 +98,32 @@ describe.each([
     expect(capturedInput).toBeUndefined();
     expect(capturedBanner).toBeDefined();
     expect(capturedBanner?.variant).toBe("info");
-    expect(capturedBanner?.children).toBe("Dieser Feldtyp kann hier noch nicht bearbeitet werden.");
     // The surrounding <Field> always renders a <label htmlFor={id}> —
     // without an id on the Banner itself that label points at nothing (#1834 review).
     expect(capturedBanner?.id).toBe("kumiko-edit-positions");
   });
+
+  // #1847#6: the Banner used to show only the generic hint, hiding the
+  // actual field value from the user entirely (not even read-only).
+  test("shows the underlying value read-only alongside the generic hint", () => {
+    renderField(field);
+    const children = capturedBanner?.children;
+    const childArray = Array.isArray(children) ? children : [children];
+    expect(childArray[0]).toBe("Dieser Feldtyp kann hier noch nicht bearbeitet werden.");
+    const valuePreview = childArray[1] as { props: { children: unknown } } | false | undefined;
+    if (!valuePreview) throw new Error("expected a value-preview element");
+    expect(valuePreview.props.children).toBe(JSON.stringify(field.value));
+  });
+});
+
+describe("RenderField — unsupported-type Banner ohne Wert", () => {
+  test("kein Value-Preview-Element wenn field.value leer ist", () => {
+    renderField(baseField({ type: "jsonb", value: null }));
+    const children = capturedBanner?.children;
+    const childArray = Array.isArray(children) ? children : [children];
+    expect(childArray[0]).toBe("Dieser Feldtyp kann hier noch nicht bearbeitet werden.");
+    expect(childArray[1]).toBeFalsy();
+  });
 });
 
 describe("RenderField — text bleibt weiterhin editierbar", () => {

package/src/components/embedded-list-field.tsx

@@ -5,11 +5,12 @@ import type {
 } from "@cosmicdrift/kumiko-headless";
 import {
   computeDerivedCellValue,
+  currencyDecimals,
   groupEmbeddedListIssues,
   roundDerivedCellValue,
   sumEmbeddedListColumn,
 } from "@cosmicdrift/kumiko-headless";
-import type { ReactNode } from "react";
+import { type ReactNode, useState } from "react";
 import { toKebab } from "../app/qn";
 import { REFERENCE_COMBOBOX_LIMIT } from "../hooks/reference-limits";
 import { useQuery } from "../hooks/use-query";
@@ -54,7 +55,7 @@ function withRecomputedDerived(
   return result;
 }
 
-function coerceCellValue(column: EmbeddedListColumn, text: string): unknown {
+function coerceCellValue(column: EmbeddedListColumn, text: string, currency: string): unknown {
   switch (column.type) {
     case "text":
       return text;
@@ -66,10 +67,15 @@ function coerceCellValue(column: EmbeddedListColumn, text: string): unknown {
     }
     case "money": {
       // Money cells are minor-unit integers (cents) in storage — paste
-      // arrives as a major-unit decimal string ("12,99"/"12.99"), so ×100.
+      // arrives as a major-unit decimal string ("12,99"/"12.99"), so scale
+      // by the currency's decimal places. Must agree with the typed-in path
+      // (renderCellControl's MoneyInput, which scales by the same
+      // currencyDecimals) — a hardcoded ×100 here diverged for zero-/three-
+      // decimal currencies (JPY, BHD, ...), landing a pasted value 100x off
+      // from the same value typed by hand (kumiko-framework#1972).
       if (text.trim() === "") return undefined;
       const n = Number(text.replace(",", "."));
-      return Number.isFinite(n) ? Math.round(n * 100) : undefined;
+      return Number.isFinite(n) ? Math.round(n * 10 ** currencyDecimals(currency)) : undefined;
     }
     case "boolean":
       return ["true", "1", "yes", "y", "ja"].includes(text.trim().toLowerCase());
@@ -104,6 +110,10 @@ export function EmbeddedListField({
 }: EmbeddedListFieldProps): ReactNode {
   const { EmbeddedListInput } = usePrimitives();
   const t = useTranslation();
+  const [pasteWarning, setPasteWarning] = useState<{
+    readonly droppedRows: number;
+    readonly unmatchedCells: number;
+  } | null>(null);
 
   const cells = field.embeddedListCells ?? [];
   const rows = Array.isArray(field.value) ? (field.value as readonly EmbeddedRow[]) : [];
@@ -163,6 +173,32 @@ export function EmbeddedListField({
   });
 
   const { listIssues, rowIssues, cellIssues } = groupEmbeddedListIssues(allIssues, field.field);
+  const combinedListIssues: readonly FieldIssue[] =
+    pasteWarning === null
+      ? listIssues
+      : [
+          ...listIssues,
+          ...(pasteWarning.droppedRows > 0
+            ? [
+                {
+                  path: field.field,
+                  code: "paste-rows-truncated",
+                  i18nKey: "kumiko.field.embedded-list.paste-rows-truncated",
+                  params: { count: pasteWarning.droppedRows },
+                },
+              ]
+            : []),
+          ...(pasteWarning.unmatchedCells > 0
+            ? [
+                {
+                  path: field.field,
+                  code: "paste-cells-unmatched",
+                  i18nKey: "kumiko.field.embedded-list.paste-cells-unmatched",
+                  params: { count: pasteWarning.unmatchedCells },
+                },
+              ]
+            : []),
+        ];
 
   function replaceRow(rowIndex: number, updater: (row: EmbeddedRow) => EmbeddedRow): void {
     const nextRows = rows.map((row, i) => (i === rowIndex ? updater(row) : row));
@@ -208,11 +244,16 @@ export function EmbeddedListField({
     const maxItems = field.embeddedListMaxItems;
     const nextRows = [...rows];
     const touchedIndices = new Set<number>();
+    let droppedRows = 0;
+    let unmatchedCells = 0;
 
     grid.forEach((gridRow, gridRowOffset) => {
       const targetRowIndex = rowIndex + gridRowOffset;
       if (targetRowIndex >= nextRows.length) {
-        if (maxItems !== undefined && nextRows.length >= maxItems) return;
+        if (maxItems !== undefined && nextRows.length >= maxItems) {
+          droppedRows += 1;
+          return;
+        }
         nextRows.push({});
       }
       const targetRow = nextRows[targetRowIndex];
@@ -221,12 +262,23 @@ export function EmbeddedListField({
       gridRow.forEach((text, gridColOffset) => {
         const column = columns[columnIndex + gridColOffset];
         if (column === undefined) return;
-        updatedRow = { ...updatedRow, [column.field]: coerceCellValue(column, text) };
+        const coerced = coerceCellValue(column, text, field.embeddedListCurrency ?? "EUR");
+        const isUnmatchedChoice =
+          (column.type === "select" || column.type === "reference") &&
+          coerced === undefined &&
+          text.trim() !== "";
+        if (isUnmatchedChoice) {
+          unmatchedCells += 1;
+          return;
+        }
+        updatedRow = { ...updatedRow, [column.field]: coerced };
       });
       nextRows[targetRowIndex] = updatedRow;
       touchedIndices.add(targetRowIndex);
     });
 
+    setPasteWarning(droppedRows > 0 || unmatchedCells > 0 ? { droppedRows, unmatchedCells } : null);
+
     const recomputed = nextRows.map((row, i) =>
       touchedIndices.has(i) ? withRecomputedDerived(row, derived, cells) : row,
     );
@@ -243,7 +295,7 @@ export function EmbeddedListField({
       disabled={field.readOnly}
       minItems={field.embeddedListMinItems}
       maxItems={field.embeddedListMaxItems}
-      listIssues={listIssues}
+      listIssues={combinedListIssues}
       rowIssues={rowIssues}
       cellIssues={cellIssues}
       onCellChange={handleCellChange}

package/src/components/reference-create-dialog.tsx

@@ -23,7 +23,7 @@ function entityWriteCommand(featureName: string, entity: string): string {
 // The create handler's success payload is `{ kind: "save", id, ... }`
 // (see event-store-executor-write.ts) but RenderEdit's onSubmit only
 // types it as `unknown` — narrow defensively instead of casting through it.
-function extractCreatedId(data: unknown): string | undefined {
+export function extractCreatedId(data: unknown): string | undefined {
   if (typeof data !== "object" || data === null) return undefined;
   const id = (data as Record<string, unknown>)["id"];
   return typeof id === "string" ? id : undefined;

package/src/components/render-edit-logic.ts

@@ -40,14 +40,9 @@ export function shouldNotifyCaller(
   return !(result.isSuccess && !extensionsPersisted);
 }
 
-// Restricts rendered sections to the caller's `fields` filter, keeping
-// section order/title/visibility from the layout unchanged. A `fields`
-// section whose filtered field list is empty is dropped entirely — an empty
-// section container would read as a broken layout, not "nothing to show
-// here". Extension sections are never filtered — they carry their own field
-// set, unrelated to the `field`-name filter. `fieldsFilter === undefined`
-// (no prop passed) returns the same array reference, so callers that skip
-// the prop keep unchanged render behavior.
+// Extension sections skip the `fields` filter (their own field set, unrelated
+// to `field`-name filtering); a `fields` section left with zero fields after
+// filtering is dropped, not rendered empty.
 export function filterEditSections(
   sections: readonly EditSectionViewModel[],
   fieldsFilter: readonly string[] | undefined,