@cosmicdrift/kumiko-renderer 0.258.1 → 0.260.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-renderer",
-  "version": "0.258.1",
+  "version": "0.260.0",
   "description": "Platform-agnostic React renderer for Kumiko screens. Contains the shared logic — primitives-contract, hooks, KumikoScreen, navigation & SSE abstractions — that any platform-specific renderer (web, native) composes. No DOM, no EventSource, no react-dom.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -15,8 +15,8 @@
     }
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-framework": "0.258.1",
-    "@cosmicdrift/kumiko-headless": "0.258.1",
+    "@cosmicdrift/kumiko-framework": "0.260.0",
+    "@cosmicdrift/kumiko-headless": "0.260.0",
     "react": "^19.2.6",
     "temporal-polyfill": "^0.3.2",
     "zod": "^4.4.3"
@@ -27,7 +27,7 @@
     "@types/react-dom": "^19.2.3",
     "jsdom": "^29.1.1",
     "react-dom": "^19.2.6",
-    "@cosmicdrift/kumiko-locale-de": "0.258.1"
+    "@cosmicdrift/kumiko-locale-de": "0.260.0"
   },
   "repository": {
     "type": "git",

package/src/app/__tests__/action-form-shim.test.ts

@@ -48,6 +48,27 @@ describe("synthesizeActionFormScreen", () => {
     });
     expect("description" in withoutDescription).toBe(false);
   });
+
+  test("carries slots through so RenderEdit can mount header/footer slots on an actionForm", () => {
+    const withSlots = synthesizeActionFormScreen({
+      id: "invite-user",
+      type: "actionForm",
+      handler: "users:write:invite-user",
+      layout: { sections: [{ title: "Invite", fields: ["email"] }] },
+      fields: { email: { type: "text" } },
+      slots: { footer: { react: { __component: "f" } } },
+    });
+    expect(withSlots.slots).toEqual({ footer: { react: { __component: "f" } } });
+
+    const withoutSlots = synthesizeActionFormScreen({
+      id: "invite-user",
+      type: "actionForm",
+      handler: "users:write:invite-user",
+      layout: { sections: [{ title: "Invite", fields: ["email"] }] },
+      fields: { email: { type: "text" } },
+    });
+    expect("slots" in withoutSlots).toBe(false);
+  });
 });
 
 describe("synthesizeSecretMintConfirmScreen (fw#2838)", () => {

package/src/app/__tests__/row-default-edit-action.test.tsx

@@ -0,0 +1,324 @@
+// kumiko-screen-akte-bedienkonzept: entityList and projectionList rowActions
+// get a default "Edit" row action for free when the row's entity has a
+// visible entityEdit screen — same cross-feature resolution as
+// projectionDetail's header defaultEditAction (fw#2166), reused here via
+// findEditScreenFor (screen-access.ts). Declared rowActions with id "edit"
+// win; access-gating and a missing entityEdit screen both suppress the
+// default. Mirrors entity-list-row-action-entity-target.test.tsx's harness.
+
+import { describe, expect, test } from "bun:test";
+import type {
+  EntityDefinition,
+  EntityEditScreenDefinition,
+  EntityListScreenDefinition,
+  ProjectionListScreenDefinition,
+} from "@cosmicdrift/kumiko-framework/ui-types";
+import type { Dispatcher } from "@cosmicdrift/kumiko-headless";
+import { render, waitFor } from "@testing-library/react";
+import type { ComponentType, ReactNode } from "react";
+import { DispatcherProvider } from "../../context/dispatcher-context";
+import { UserRolesProvider } from "../../context/user-roles-context";
+import { createStaticLocaleResolver, LocaleProvider } from "../../i18n";
+import { kumikoDefaultTranslations } from "../../i18n-defaults";
+import {
+  type CorePrimitives,
+  type DataTableProps,
+  type DataTableRowAction,
+  PrimitivesProvider,
+} from "../../primitives";
+import { AppFeaturesProvider } from "../app-features-context";
+import type { FeatureSchema } from "../feature-schema";
+import { KumikoScreen } from "../kumiko-screen";
+import type { NavTarget } from "../nav";
+import { NavProvider } from "../nav";
+
+function stubDispatcher(rows: readonly Record<string, unknown>[]): Dispatcher {
+  return {
+    write: (async () => ({ isSuccess: true, data: {} })) as unknown as Dispatcher["write"],
+    query: (async () => ({
+      isSuccess: true,
+      data: { rows, nextCursor: null, total: rows.length },
+    })) as unknown as Dispatcher["query"],
+    batch: (async () => ({ isSuccess: true, results: [] })) as unknown as Dispatcher["batch"],
+    statusStore: {
+      getState: () => "online",
+      subscribe: () => () => {},
+    } as unknown as Dispatcher["statusStore"],
+    async *stream() {},
+    pendingWrites: () => [],
+    pendingFiles: () => [],
+  };
+}
+
+type Captured = {
+  readonly rowActions: readonly DataTableRowAction[] | undefined;
+  readonly rowCount: number;
+};
+let captured: Captured = { rowActions: undefined, rowCount: 0 };
+const captureDataTable: ComponentType<DataTableProps> = (props) => {
+  captured = { rowActions: props.rowActions, rowCount: props.rows.length };
+  return null;
+};
+const noop = (): ReactNode => null;
+const passChildren = ({ children }: { readonly children?: ReactNode }): ReactNode => children;
+
+const testPrimitives: CorePrimitives = {
+  Button: noop,
+  Banner: passChildren,
+  Field: passChildren,
+  Input: noop,
+  DataTable: captureDataTable,
+  Form: passChildren,
+  Section: passChildren,
+  Card: passChildren,
+  Grid: passChildren,
+  GridCell: passChildren,
+  Text: passChildren,
+  Heading: noop,
+  Dialog: noop,
+  Modal: noop,
+  Lightbox: noop,
+  ConfigSourceBadge: noop,
+  ConfigCascadeView: noop,
+  Link: noop,
+};
+
+function editScreen(entity: string, roles?: readonly string[]): EntityEditScreenDefinition {
+  return {
+    id: "app:screen:rent-edit",
+    type: "entityEdit",
+    entity,
+    layout: { sections: [{ columns: 1, fields: ["name"] }] },
+    ...(roles !== undefined && { access: { roles } }),
+  };
+}
+
+function requireAction(id: string): DataTableRowAction {
+  const action = captured.rowActions?.find((a) => a.id === id);
+  if (!action) throw new Error(`expected the '${id}' row action to be captured`);
+  return action;
+}
+
+function renderScreen(
+  schema: FeatureSchema,
+  qn: string,
+  navigateSpy: (target: NavTarget) => void,
+  userRoles: readonly string[],
+): void {
+  render(
+    <LocaleProvider
+      resolver={createStaticLocaleResolver({ locale: "en" })}
+      fallbackBundles={[kumikoDefaultTranslations]}
+    >
+      <DispatcherProvider dispatcher={stubDispatcher([{ id: "row-1", name: "Alice" }])}>
+        <AppFeaturesProvider features={[schema]}>
+          <UserRolesProvider roles={userRoles}>
+            <NavProvider
+              value={{
+                route: undefined,
+                navigate: navigateSpy,
+                replace: () => {},
+                hrefFor: () => "",
+                searchParams: {},
+                setSearchParams: () => {},
+              }}
+            >
+              <PrimitivesProvider value={testPrimitives}>
+                <KumikoScreen schema={schema} qn={qn} />
+              </PrimitivesProvider>
+            </NavProvider>
+          </UserRolesProvider>
+        </AppFeaturesProvider>
+      </DispatcherProvider>
+    </LocaleProvider>,
+  );
+}
+
+const entity: EntityDefinition = {
+  fields: {
+    name: { type: "text", maxLength: 50, required: false, searchable: false, sortable: false },
+  },
+};
+
+describe("entityList default edit row action", () => {
+  function schemaWith(
+    rowActions?: EntityListScreenDefinition["rowActions"],
+    includeEdit = true,
+  ): FeatureSchema {
+    const listScreen: EntityListScreenDefinition = {
+      id: "rent-list",
+      type: "entityList",
+      entity: "rent",
+      columns: ["name"],
+      ...(rowActions !== undefined && { rowActions }),
+    };
+    return {
+      featureName: "app",
+      entities: { rent: entity },
+      screens: includeEdit ? [listScreen, editScreen("rent")] : [listScreen],
+    };
+  }
+
+  test("adds a default edit action at the first position when an entityEdit screen exists", async () => {
+    captured = { rowActions: undefined, rowCount: 0 };
+    const navigateCalls: NavTarget[] = [];
+    renderScreen(schemaWith(undefined), "app:screen:rent-list", (t) => navigateCalls.push(t), []);
+    await waitFor(() => expect(captured.rowCount).toBe(1));
+
+    expect(captured.rowActions?.[0]?.id).toBe("edit");
+    expect(captured.rowActions?.[0]?.label).toBe("Edit");
+
+    await requireAction("edit").onTrigger({
+      id: "row-1",
+      values: { id: "row-1", name: "Alice" },
+    });
+    expect(navigateCalls).toEqual([{ screenId: "rent-edit", entityId: "row-1" }]);
+  });
+
+  test("a declared rowAction with id 'edit' wins — no doubling", async () => {
+    captured = { rowActions: undefined, rowCount: 0 };
+    renderScreen(
+      schemaWith([{ kind: "navigate", id: "edit", label: "custom-edit", screen: "rent-edit" }]),
+      "app:screen:rent-list",
+      () => {},
+      [],
+    );
+    await waitFor(() => expect(captured.rowCount).toBe(1));
+
+    const editActions = captured.rowActions?.filter((a) => a.id === "edit") ?? [];
+    expect(editActions).toHaveLength(1);
+    // "custom-edit" has no translation registered, so translate() returns
+    // the raw key — proving this is the declared action, not the default
+    // (whose label is the translated "kumiko.actions.edit" → "Edit").
+    expect(editActions[0]?.label).toBe("custom-edit");
+  });
+
+  test("no entityEdit screen for the entity → no default edit action", async () => {
+    captured = { rowActions: undefined, rowCount: 0 };
+    renderScreen(schemaWith(undefined, false), "app:screen:rent-list", () => {}, []);
+    await waitFor(() => expect(captured.rowCount).toBe(1));
+
+    expect(captured.rowActions?.some((a) => a.id === "edit") ?? false).toBe(false);
+  });
+
+  test("access denied to the entityEdit screen → no default edit action", async () => {
+    captured = { rowActions: undefined, rowCount: 0 };
+    const listScreen: EntityListScreenDefinition = {
+      id: "rent-list",
+      type: "entityList",
+      entity: "rent",
+      columns: ["name"],
+    };
+    const schema: FeatureSchema = {
+      featureName: "app",
+      entities: { rent: entity },
+      screens: [listScreen, editScreen("rent", ["admin"])],
+    };
+    renderScreen(schema, "app:screen:rent-list", () => {}, []);
+    await waitFor(() => expect(captured.rowCount).toBe(1));
+
+    expect(captured.rowActions?.some((a) => a.id === "edit") ?? false).toBe(false);
+  });
+});
+
+describe("projectionList default edit row action", () => {
+  function schemaWith(
+    rowActions?: ProjectionListScreenDefinition["rowActions"],
+    includeEdit = true,
+  ): FeatureSchema {
+    const listScreen: ProjectionListScreenDefinition = {
+      id: "rent-projection-list",
+      type: "projectionList",
+      query: "app:query:rent:list",
+      detailFor: "rent",
+      columns: [{ field: "name", label: "Name" }],
+      ...(rowActions !== undefined && { rowActions }),
+    };
+    return {
+      featureName: "app",
+      entities: {},
+      screens: includeEdit ? [listScreen, editScreen("rent")] : [listScreen],
+    };
+  }
+
+  test("adds a default edit action at the first position when detailFor resolves an entityEdit screen", async () => {
+    captured = { rowActions: undefined, rowCount: 0 };
+    const navigateCalls: NavTarget[] = [];
+    renderScreen(
+      schemaWith(undefined),
+      "app:screen:rent-projection-list",
+      (t) => navigateCalls.push(t),
+      [],
+    );
+    await waitFor(() => expect(captured.rowCount).toBe(1));
+
+    expect(captured.rowActions?.[0]?.id).toBe("edit");
+    expect(captured.rowActions?.[0]?.label).toBe("Edit");
+
+    await requireAction("edit").onTrigger({
+      id: "row-1",
+      values: { id: "row-1", name: "Alice" },
+    });
+    expect(navigateCalls).toEqual([{ screenId: "rent-edit", entityId: "row-1" }]);
+  });
+
+  test("a declared rowAction with id 'edit' wins — no doubling", async () => {
+    captured = { rowActions: undefined, rowCount: 0 };
+    renderScreen(
+      schemaWith([{ kind: "navigate", id: "edit", label: "custom-edit", screen: "rent-edit" }]),
+      "app:screen:rent-projection-list",
+      () => {},
+      [],
+    );
+    await waitFor(() => expect(captured.rowCount).toBe(1));
+
+    const editActions = captured.rowActions?.filter((a) => a.id === "edit") ?? [];
+    expect(editActions).toHaveLength(1);
+    expect(editActions[0]?.label).toBe("custom-edit");
+  });
+
+  test("no detailFor → no default edit action", async () => {
+    captured = { rowActions: undefined, rowCount: 0 };
+    const listScreen: ProjectionListScreenDefinition = {
+      id: "rent-projection-list",
+      type: "projectionList",
+      query: "app:query:rent:list",
+      columns: [{ field: "name", label: "Name" }],
+    };
+    const schema: FeatureSchema = {
+      featureName: "app",
+      entities: {},
+      screens: [listScreen, editScreen("rent")],
+    };
+    renderScreen(schema, "app:screen:rent-projection-list", () => {}, []);
+    await waitFor(() => expect(captured.rowCount).toBe(1));
+
+    expect(captured.rowActions?.some((a) => a.id === "edit") ?? false).toBe(false);
+  });
+
+  test("access denied to the entityEdit screen → no default edit action", async () => {
+    captured = { rowActions: undefined, rowCount: 0 };
+    renderScreen(
+      {
+        featureName: "app",
+        entities: {},
+        screens: [
+          {
+            id: "rent-projection-list",
+            type: "projectionList",
+            query: "app:query:rent:list",
+            detailFor: "rent",
+            columns: [{ field: "name", label: "Name" }],
+          },
+          editScreen("rent", ["admin"]),
+        ],
+      },
+      "app:screen:rent-projection-list",
+      () => {},
+      [],
+    );
+    await waitFor(() => expect(captured.rowCount).toBe(1));
+
+    expect(captured.rowActions?.some((a) => a.id === "edit") ?? false).toBe(false);
+  });
+});

package/src/app/action-form-shim.ts

@@ -50,6 +50,9 @@ export function synthesizeActionFormScreen(
     layout: screen.layout,
     ...(screen.description !== undefined && { description: screen.description }),
     ...(screen.access !== undefined && { access: screen.access }),
+    // Only ActionFormScreenDefinition carries slots — SecretMintScreenDefinition
+    // has none, so `in` is the narrowing (no cast).
+    ...("slots" in screen && screen.slots !== undefined && { slots: screen.slots }),
   };
 }
 

package/src/app/dashboard-body.tsx

@@ -8,6 +8,7 @@ import type { Translate } from "@cosmicdrift/kumiko-headless";
 import { type ComponentType, createContext, type ReactNode, useContext } from "react";
 
 export type DashboardBodyProps = {
+  readonly featureName: string;
   readonly screen: DashboardScreenDefinition;
   readonly translate?: Translate;
 };

package/src/app/extension-sections.tsx

@@ -4,6 +4,7 @@
 // PlatformComponent über dieselbe Registry auf und mountet die passende
 // Component — die Bundled-Feature-/App-Component lädt + persistiert dann
 // ihre eigenen Daten (z.B. custom-fields, oder ein eigenständiger Chart).
+// The entityEdit footer slot (`screen.slots.footer`) mounts through it too.
 //
 // Mounting analog zu CustomScreensProvider — createKumikoApp im
 // renderer-web sammelt alle clientFeatures.extensionSectionComponents und
@@ -66,6 +67,14 @@ export type ExtensionSectionProps = {
    *  `snapshot.errors` on the field instead of a collective message.
    *  Undefined outside entityEdit sections. */
   readonly validate?: () => boolean;
+  /** Whether the host form has unsaved changes. Only set in the entityEdit
+   *  footer slot (`screen.slots.footer`); undefined in all other mounts. */
+  readonly hasUnsavedChanges?: boolean;
+  /** Current wizard step, only set for `layout.mode === "wizard"` forms.
+   *  Only set in the entityEdit footer slot (`screen.slots.footer`);
+   *  undefined in all other mounts, and undefined there too for a
+   *  non-wizard form. */
+  readonly wizardStep?: { readonly index: number; readonly isLast: boolean };
 };
 
 export type ExtensionSectionComponent = ComponentType<ExtensionSectionProps>;