@cosmicdrift/kumiko-renderer 0.328.0 → 0.328.1

package/src/components/__tests__/render-edit-action-button.test.tsx

@@ -1,205 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { fireEvent, render, screen as rtlScreen, waitFor } from "@testing-library/react";
-import type { ComponentType } from "react";
-import type { ButtonProps, DialogProps } from "../../primitives";
-import { RenderEditActionButton } from "../render-edit-action-button";
-import type { RenderEditAction } from "../render-edit-types";
-
-const TestButton: ComponentType<ButtonProps> = ({ children, onClick, testId, type, loading }) => (
-  <button
-    type={type ?? "button"}
-    data-testid={testId}
-    data-loading={loading ? "1" : "0"}
-    onClick={() => {
-      void onClick?.();
-    }}
-  >
-    {children}
-  </button>
-);
-
-const TestDialog: ComponentType<DialogProps> = ({
-  open,
-  onOpenChange,
-  title,
-  description,
-  confirmLabel,
-  variant,
-  onConfirm,
-  testId,
-}) =>
-  open ? (
-    <div data-testid={testId} data-variant={variant ?? "default"}>
-      <span data-testid={`${testId}-title`}>{title}</span>
-      {description !== undefined && (
-        <span data-testid={`${testId}-description`}>{description}</span>
-      )}
-      <button
-        type="button"
-        data-testid={`${testId}-confirm`}
-        onClick={() => {
-          void (async () => {
-            await onConfirm();
-            onOpenChange(false);
-          })();
-        }}
-      >
-        {confirmLabel ?? "Confirm"}
-      </button>
-      <button type="button" data-testid={`${testId}-cancel`} onClick={() => onOpenChange(false)}>
-        Cancel
-      </button>
-    </div>
-  ) : null;
-
-function renderAction(action: RenderEditAction, onError: (text: string | null) => void = () => {}) {
-  return render(
-    <RenderEditActionButton
-      action={action}
-      Button={TestButton}
-      Dialog={TestDialog}
-      onError={onError}
-    />,
-  );
-}
-
-describe("RenderEditActionButton", () => {
-  test("secondary action without confirm runs onPress immediately", async () => {
-    let pressed = 0;
-    renderAction({
-      id: "ping",
-      label: "Ping",
-      onPress: async () => {
-        pressed += 1;
-      },
-    });
-
-    expect(rtlScreen.queryByTestId("render-edit-action-ping-dialog")).toBeNull();
-    fireEvent.click(rtlScreen.getByTestId("render-edit-action-ping"));
-    await waitFor(() => expect(pressed).toBe(1));
-  });
-
-  test("explicit confirm text opens dialog; confirm runs onPress, cancel does not", async () => {
-    let pressed = 0;
-    renderAction({
-      id: "archive",
-      label: "Archive",
-      confirm: "Really archive?",
-      confirmLabel: "Yes, archive",
-      onPress: async () => {
-        pressed += 1;
-      },
-    });
-
-    fireEvent.click(rtlScreen.getByTestId("render-edit-action-archive"));
-    expect(rtlScreen.getByTestId("render-edit-action-archive-dialog")).toBeTruthy();
-    expect(rtlScreen.getByTestId("render-edit-action-archive-dialog-description").textContent).toBe(
-      "Really archive?",
-    );
-    expect(rtlScreen.getByTestId("render-edit-action-archive-dialog-confirm").textContent).toBe(
-      "Yes, archive",
-    );
-
-    fireEvent.click(rtlScreen.getByTestId("render-edit-action-archive-dialog-cancel"));
-    expect(rtlScreen.queryByTestId("render-edit-action-archive-dialog")).toBeNull();
-    expect(pressed).toBe(0);
-
-    fireEvent.click(rtlScreen.getByTestId("render-edit-action-archive"));
-    fireEvent.click(rtlScreen.getByTestId("render-edit-action-archive-dialog-confirm"));
-    await waitFor(() => expect(pressed).toBe(1));
-    await waitFor(() =>
-      expect(rtlScreen.queryByTestId("render-edit-action-archive-dialog")).toBeNull(),
-    );
-  });
-
-  test("danger style forces confirm dialog even without confirm text", async () => {
-    let pressed = 0;
-    renderAction({
-      id: "delete",
-      label: "Delete",
-      style: "danger",
-      onPress: async () => {
-        pressed += 1;
-      },
-    });
-
-    fireEvent.click(rtlScreen.getByTestId("render-edit-action-delete"));
-    const dialog = rtlScreen.getByTestId("render-edit-action-delete-dialog");
-    expect(dialog.getAttribute("data-variant")).toBe("danger");
-    expect(rtlScreen.queryByTestId("render-edit-action-delete-dialog-description")).toBeNull();
-    expect(pressed).toBe(0);
-
-    expect(rtlScreen.getByTestId("render-edit-action-delete-dialog-confirm").textContent).toBe(
-      "Delete",
-    );
-
-    fireEvent.click(rtlScreen.getByTestId("render-edit-action-delete-dialog-confirm"));
-    await waitFor(() => expect(pressed).toBe(1));
-  });
-
-  // fw#2752: schema-driven navigate/drawer actions set confirmRequired: false
-  // to opt a danger-styled action out of the forced dialog — the colour still
-  // marks it destructive, but the target form is itself the confirmation.
-  test("danger style with confirmRequired=false fires onPress directly, no dialog", async () => {
-    let pressed = 0;
-    renderAction({
-      id: "open-terminate-form",
-      label: "Terminate",
-      style: "danger",
-      confirmRequired: false,
-      onPress: async () => {
-        pressed += 1;
-      },
-    });
-
-    fireEvent.click(rtlScreen.getByTestId("render-edit-action-open-terminate-form"));
-    expect(rtlScreen.queryByTestId("render-edit-action-open-terminate-form-dialog")).toBeNull();
-    await waitFor(() => expect(pressed).toBe(1));
-  });
-
-  test("onPress failure reports via onError", async () => {
-    const errors: Array<string | null> = [];
-    renderAction(
-      {
-        id: "boom",
-        label: "Boom",
-        onPress: async () => {
-          throw new Error("action exploded");
-        },
-      },
-      (text) => {
-        errors.push(text);
-      },
-    );
-
-    fireEvent.click(rtlScreen.getByTestId("render-edit-action-boom"));
-    await waitFor(() => expect(errors).toContain("action exploded"));
-    // Cleared at the start of trigger, then set on failure.
-    expect(errors[0]).toBeNull();
-  });
-
-  test("sets loading while onPress is in flight", async () => {
-    let resolvePress!: () => void;
-    const pressPromise = new Promise<void>((resolve) => {
-      resolvePress = resolve;
-    });
-    renderAction({
-      id: "slow",
-      label: "Slow",
-      onPress: () => pressPromise,
-    });
-
-    fireEvent.click(rtlScreen.getByTestId("render-edit-action-slow"));
-    await waitFor(() =>
-      expect(rtlScreen.getByTestId("render-edit-action-slow").getAttribute("data-loading")).toBe(
-        "1",
-      ),
-    );
-    resolvePress();
-    await waitFor(() =>
-      expect(rtlScreen.getByTestId("render-edit-action-slow").getAttribute("data-loading")).toBe(
-        "0",
-      ),
-    );
-  });
-});

package/src/components/__tests__/render-edit-hidden-section.test.tsx

@@ -1,128 +0,0 @@
-// Regression coverage for the hidden-section guards in render-edit.tsx
-// (kumiko-framework#1731, from PR-review finding #1690): nothing previously
-// asserted that a fully-hidden section actually stays out of the DOM.
-//
-// Two cases, verified by mutation-testing each guard in isolation:
-//  - "Hidden": a "fields" section whose only field is condition-hidden — the
-//    issue's literal ask. Redundantly guarded: both the
-//    `filterEditSections(...).filter(...)` pass and the render loop's
-//    `if (!section.visible) return null;` independently suppress it, so this
-//    case only goes red if BOTH guards are removed.
-//  - "Empty": a "fields" section declared with zero fields. fw#1901 keeps it
-//    past the filter above on purpose (it isn't "hidden", it just has
-//    nothing to hide), so its `visible` stays vacuously false and
-//    `if (!section.visible) return null;` is the ONLY thing nulling it out —
-//    this case is what actually pins that line, verified red when it's
-//    neutralized. Not a shape a booted app can produce (boot-validator
-//    rejects `fields.length === 0`), but RenderEdit's props aren't
-//    boot-validated, so it's a real call shape worth guarding.
-
-import { describe, expect, test } from "bun:test";
-import type {
-  EntityDefinition,
-  EntityEditScreenDefinition,
-} from "@cosmicdrift/kumiko-framework/ui-types";
-import { type RenderResult, render } from "@testing-library/react";
-import type { ComponentType, ReactNode } from "react";
-import { createStaticLocaleResolver, LocaleProvider } from "../../i18n";
-import { kumikoDefaultTranslations } from "../../i18n-defaults";
-import { type CorePrimitives, PrimitivesProvider, type SectionProps } from "../../primitives";
-import { RenderEdit } from "../render-edit";
-
-const noop = (): ReactNode => null;
-const passChildren = ({ children }: { readonly children?: ReactNode }): ReactNode => children;
-const renderSection: ComponentType<SectionProps> = ({ testId, children }) => (
-  <div data-testid={testId}>{children}</div>
-);
-
-function testPrimitives(): CorePrimitives {
-  return {
-    Button: noop,
-    Banner: noop,
-    Field: passChildren,
-    Input: noop,
-    DataTable: noop,
-    Form: passChildren,
-    Section: renderSection,
-    Card: passChildren,
-    Grid: passChildren,
-    GridCell: passChildren,
-    Text: passChildren,
-    Heading: noop,
-    Dialog: noop,
-    Modal: noop,
-    Lightbox: noop,
-    ConfigSourceBadge: noop,
-    ConfigCascadeView: noop,
-    Link: noop,
-  };
-}
-
-function buildEntity(): EntityDefinition {
-  return {
-    fields: {
-      name: { type: "text", maxLength: 200, required: false, searchable: false, sortable: false },
-      secret: { type: "text", maxLength: 200, required: false, searchable: false, sortable: false },
-    },
-  };
-}
-
-function renderEdit(screen: EntityEditScreenDefinition): RenderResult {
-  return render(
-    <LocaleProvider
-      resolver={createStaticLocaleResolver({ locale: "en-US" })}
-      fallbackBundles={[kumikoDefaultTranslations]}
-    >
-      <PrimitivesProvider value={testPrimitives()}>
-        <RenderEdit
-          screen={screen}
-          entity={buildEntity()}
-          featureName="widgets"
-          initial={{ name: "", secret: "" }}
-        />
-      </PrimitivesProvider>
-    </LocaleProvider>,
-  );
-}
-
-describe("RenderEdit — section with every field condition-hidden", () => {
-  test("the visible section renders, the fully-hidden one does not reach the DOM", () => {
-    const screen: EntityEditScreenDefinition = {
-      id: "widget-edit",
-      type: "entityEdit",
-      entity: "widget",
-      layout: {
-        sections: [
-          { title: "Visible", fields: ["name"] },
-          { title: "Hidden", fields: [{ field: "secret", visible: false }] },
-        ],
-      },
-    };
-
-    const { getByTestId, queryByTestId } = renderEdit(screen);
-
-    expect(getByTestId("section-Visible")).toBeDefined();
-    expect(queryByTestId("section-Hidden")).toBeNull();
-  });
-});
-
-describe("RenderEdit — section declared with zero fields", () => {
-  test("the visible section renders, the empty one does not reach the DOM", () => {
-    const screen: EntityEditScreenDefinition = {
-      id: "widget-edit",
-      type: "entityEdit",
-      entity: "widget",
-      layout: {
-        sections: [
-          { title: "Visible", fields: ["name"] },
-          { title: "Empty", fields: [] },
-        ],
-      },
-    };
-
-    const { getByTestId, queryByTestId } = renderEdit(screen);
-
-    expect(getByTestId("section-Visible")).toBeDefined();
-    expect(queryByTestId("section-Empty")).toBeNull();
-  });
-});

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

@@ -1,314 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type {
-  DispatcherError,
-  EditFieldViewModel,
-  EditSectionViewModel,
-  SubmitResult,
-} from "@cosmicdrift/kumiko-headless";
-import {
-  filterEditSections,
-  hasEditableSection,
-  hasIssueWithoutRenderedField,
-  resolveExtensionEntityId,
-  shouldNotifyCaller,
-} from "../render-edit-logic";
-
-const error: DispatcherError = {
-  code: "internal_error",
-  httpStatus: 500,
-  i18nKey: "kumiko.errors.internal",
-  message: "boom",
-};
-
-const success: SubmitResult<unknown> = { validationBlocked: false, isSuccess: true, data: {} };
-const writeFailure: SubmitResult<unknown> = { validationBlocked: false, isSuccess: false, error };
-const validationBlocked: SubmitResult<unknown> = { validationBlocked: true, isSuccess: false };
-
-describe("resolveExtensionEntityId", () => {
-  test("explicit id prop wins over vm.id", () => {
-    expect(resolveExtensionEntityId("entity-42", "row-7")).toBe("entity-42");
-  });
-
-  // The #345/1 regression: mount fell back to vm.id but persist did not, so a
-  // custom-fields section mounted editable against the existing row yet saved
-  // to null → silent data loss. Both sites now resolve this same value.
-  test("undefined prop → vm.id fallback (update form carries the row id)", () => {
-    expect(resolveExtensionEntityId(undefined, "row-42")).toBe("row-42");
-  });
-
-  test("undefined prop + no vm.id (create mode) → null", () => {
-    expect(resolveExtensionEntityId(undefined, null)).toBeNull();
-  });
-
-  test("explicit null prop forces null even when vm.id is present", () => {
-    expect(resolveExtensionEntityId(null, "row-42")).toBeNull();
-  });
-});
-
-describe("shouldNotifyCaller", () => {
-  // The one case the #345/1 fix changes: a successful entity write whose
-  // extension persist failed must NOT notify (caller would navigate away and
-  // unmount the extension-error banner → silent custom-field data loss). The
-  // pre-fix code notified unconditionally, so this row flips false↔true.
-  test("entity success + extension persist failed → suppress callback", () => {
-    expect(shouldNotifyCaller(success, false)).toBe(false);
-  });
-
-  test("entity success + extensions persisted → notify", () => {
-    expect(shouldNotifyCaller(success, true)).toBe(true);
-  });
-
-  test("entity write failure → notify (caller needs the error result)", () => {
-    expect(shouldNotifyCaller(writeFailure, true)).toBe(true);
-    // extensions never run on a failed entity write, but the flag must not
-    // swallow the failure callback regardless of its value.
-    expect(shouldNotifyCaller(writeFailure, false)).toBe(true);
-  });
-
-  test("validation blocked → notify", () => {
-    expect(shouldNotifyCaller(validationBlocked, true)).toBe(true);
-  });
-});
-
-const field = (readOnly: boolean): EditFieldViewModel => ({
-  field: "f",
-  label: "F",
-  type: "text",
-  value: "",
-  visible: true,
-  readOnly,
-  required: false,
-});
-const fieldsSection = (...readOnly: boolean[]): EditSectionViewModel => ({
-  kind: "fields",
-  columns: 1,
-  visible: true,
-  fields: readOnly.map(field),
-});
-const extensionSection: EditSectionViewModel = {
-  kind: "extension",
-  title: "Custom",
-  component: {},
-  contributesToFormSubmit: false,
-};
-const composedExtensionSection: EditSectionViewModel = {
-  ...extensionSection,
-  contributesToFormSubmit: true,
-};
-
-describe("hasEditableSection", () => {
-  // A read-only inspector detail (export-job/download-attempt) marks every field
-  // readOnly + has no create/delete — there is nothing to submit, so the Save
-  // button must not render at all (a disabled one reads as a broken control).
-  test("every field readOnly → false (no Save button)", () => {
-    expect(hasEditableSection([fieldsSection(true, true, true)])).toBe(false);
-  });
-
-  test("one editable field → true", () => {
-    expect(hasEditableSection([fieldsSection(true, false)])).toBe(true);
-  });
-
-  test("editable field in a later section → true", () => {
-    expect(hasEditableSection([fieldsSection(true), fieldsSection(false)])).toBe(true);
-  });
-
-  test("extension section without form-submit opt-in → false", () => {
-    expect(hasEditableSection([extensionSection])).toBe(false);
-  });
-
-  test("extension section with contributesToFormSubmit → true", () => {
-    expect(hasEditableSection([composedExtensionSection])).toBe(true);
-  });
-
-  test("no sections → false", () => {
-    expect(hasEditableSection([])).toBe(false);
-  });
-
-  // writeForm owns its own submit button (write-form-section-submit) —
-  // counting it here would additionally render the screen-level Save button
-  // (render-edit-submit) on a projectionDetail, which has no form submit to
-  // wire it to.
-  test("writeForm section → false (has its own submit, not the screen's)", () => {
-    const writeFormSection: EditSectionViewModel = {
-      kind: "writeForm",
-      columns: 1,
-      handler: "orders:write:add-note",
-      fields: [field(false)],
-    };
-    expect(hasEditableSection([writeFormSection])).toBe(false);
-  });
-
-  test("hidden section with editable field → false (user cannot see the field)", () => {
-    const hiddenSectionWithEditableField: EditSectionViewModel = {
-      kind: "fields",
-      columns: 1,
-      visible: false,
-      fields: [field(false)],
-    };
-    expect(hasEditableSection([hiddenSectionWithEditableField])).toBe(false);
-  });
-
-  test("visible section with only a field-hidden editable field → false", () => {
-    const section: EditSectionViewModel = {
-      kind: "fields",
-      columns: 1,
-      visible: true,
-      fields: [
-        {
-          field: "f",
-          label: "F",
-          type: "text",
-          value: "",
-          visible: false,
-          readOnly: false,
-          required: false,
-        },
-      ],
-    };
-    expect(hasEditableSection([section])).toBe(false);
-  });
-
-  // The #1689 regression: the section is visible because field A is visible
-  // (readOnly), but the only editable field B is hidden by its own
-  // FieldCondition. Old code checked section.visible + !readOnly only, so it
-  // saw B's !readOnly and returned true — Save appeared over zero editable
-  // visible fields.
-  test("visible section, visible readOnly field + hidden editable field → false", () => {
-    const section: EditSectionViewModel = {
-      kind: "fields",
-      columns: 1,
-      visible: true,
-      fields: [
-        {
-          field: "a",
-          label: "A",
-          type: "text",
-          value: "",
-          visible: true,
-          readOnly: true,
-          required: false,
-        },
-        {
-          field: "b",
-          label: "B",
-          type: "text",
-          value: "",
-          visible: false,
-          readOnly: false,
-          required: false,
-        },
-      ],
-    };
-    expect(hasEditableSection([section])).toBe(false);
-  });
-});
-
-const namedField = (name: string): EditFieldViewModel => ({
-  field: name,
-  label: name,
-  type: "text",
-  value: "",
-  visible: true,
-  readOnly: false,
-  required: false,
-});
-const namedFieldsSection = (...names: string[]): EditSectionViewModel => ({
-  kind: "fields",
-  columns: 1,
-  visible: true,
-  fields: names.map(namedField),
-});
-
-describe("filterEditSections", () => {
-  test("fieldsFilter undefined → returns the same array reference (unchanged behavior)", () => {
-    const sections = [namedFieldsSection("a", "b")];
-    expect(filterEditSections(sections, undefined)).toBe(sections);
-  });
-
-  test("mixed section → only the filtered-in fields remain in section.fields", () => {
-    const sections = [namedFieldsSection("a", "b", "c")];
-    const result = filterEditSections(sections, ["a", "c"]);
-    expect(result).toHaveLength(1);
-    expect(result[0]?.kind).toBe("fields");
-    expect(result[0]?.kind === "fields" ? result[0].fields.map((f) => f.field) : []).toEqual([
-      "a",
-      "c",
-    ]);
-  });
-
-  test("section whose filtered field list becomes empty is dropped entirely, not rendered empty", () => {
-    const sections = [namedFieldsSection("a", "b"), namedFieldsSection("c")];
-    const result = filterEditSections(sections, ["c"]);
-    expect(result).toHaveLength(1);
-    expect(result[0]?.kind === "fields" ? result[0].fields.map((f) => f.field) : []).toEqual(["c"]);
-  });
-
-  test("extension section always survives the filter regardless of its content", () => {
-    const sections = [extensionSection, namedFieldsSection("a")];
-    const result = filterEditSections(sections, ["zzz"]);
-    expect(result).toEqual([extensionSection]);
-  });
-});
-
-describe("hasIssueWithoutRenderedField", () => {
-  test("issue path matches a rendered field → false", () => {
-    expect(hasIssueWithoutRenderedField(["title"], [namedFieldsSection("title", "body")])).toBe(
-      false,
-    );
-  });
-
-  // Root-level refine issues (`version`/`id`/`changes`) never match a rendered
-  // field name — the banner is the only place that can show them.
-  test("root-level refine path (version) → true", () => {
-    expect(hasIssueWithoutRenderedField(["version"], [namedFieldsSection("title")])).toBe(true);
-  });
-
-  test("(root) path → true", () => {
-    expect(hasIssueWithoutRenderedField(["(root)"], [namedFieldsSection("title")])).toBe(true);
-  });
-
-  test("path matches a field hidden by its own condition → true", () => {
-    const section: EditSectionViewModel = {
-      kind: "fields",
-      columns: 1,
-      visible: true,
-      fields: [
-        {
-          field: "a",
-          label: "A",
-          type: "text",
-          value: "",
-          visible: true,
-          readOnly: false,
-          required: false,
-        },
-        {
-          field: "b",
-          label: "B",
-          type: "text",
-          value: "",
-          visible: false,
-          readOnly: false,
-          required: false,
-        },
-      ],
-    };
-    expect(hasIssueWithoutRenderedField(["b"], [section])).toBe(true);
-  });
-
-  test("dotted path (tasks.2.title) matches on its first segment → false", () => {
-    expect(hasIssueWithoutRenderedField(["tasks.2.title"], [namedFieldsSection("tasks")])).toBe(
-      false,
-    );
-  });
-
-  test("mixed: one matched, one unmatched → true", () => {
-    expect(hasIssueWithoutRenderedField(["title", "version"], [namedFieldsSection("title")])).toBe(
-      true,
-    );
-  });
-
-  test("empty issue list → true (single-section path always shows the banner then)", () => {
-    expect(hasIssueWithoutRenderedField([], [namedFieldsSection("title")])).toBe(true);
-  });
-});