@cosmicdrift/kumiko-renderer 0.233.0 → 0.235.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-renderer",
-  "version": "0.233.0",
+  "version": "0.235.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.233.0",
-    "@cosmicdrift/kumiko-headless": "0.233.0",
+    "@cosmicdrift/kumiko-framework": "0.235.0",
+    "@cosmicdrift/kumiko-headless": "0.235.0",
     "react": "^19.2.6",
     "temporal-polyfill": "^0.3.2",
     "zod": "^4.4.3"
@@ -24,8 +24,10 @@
   "devDependencies": {
     "@testing-library/react": "^16.3.2",
     "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
     "jsdom": "^29.1.1",
-    "@cosmicdrift/kumiko-locale-de": "0.233.0"
+    "react-dom": "^19.2.6",
+    "@cosmicdrift/kumiko-locale-de": "0.235.0"
   },
   "repository": {
     "type": "git",

package/src/__tests__/i18n.test.tsx

@@ -2,12 +2,14 @@ import { describe, expect, test } from "bun:test";
 import type { LocaleResolver } from "@cosmicdrift/kumiko-headless";
 import { act, render, renderHook } from "@testing-library/react";
 import type { ReactNode } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
 import {
   createStaticLocaleResolver,
   LocaleProvider,
   type TranslationsByLocale,
   translationsByLocaleFromKeys,
   useLocale,
+  useOptionalTranslation,
   useTranslation,
 } from "../i18n";
 
@@ -171,3 +173,40 @@ describe("useLocale", () => {
     expect(result.current.locale()).toBe("de");
   });
 });
+describe("useTranslation — SSR", () => {
+  // kumiko-framework#2595: getServerSnapshot hardcoded "en", so any
+  // server render came out English regardless of the resolver's actual
+  // locale — untestable via renderToStaticMarkup until getServerSnapshot
+  // read the resolver instead of a constant.
+  test(`renderToStaticMarkup with a non-English resolver renders the resolver's locale, not "en"`, () => {
+    const resolver = createStaticLocaleResolver({ locale: "de" });
+    const bundles: TranslationsByLocale[] = [{ de: { greet: "Hallo" }, en: { greet: "Hello" } }];
+    function Probe(): ReactNode {
+      const t = useTranslation();
+      return <span>{t("greet")}</span>;
+    }
+    const html = renderToStaticMarkup(
+      <LocaleProvider resolver={resolver} fallbackBundles={bundles}>
+        <Probe />
+      </LocaleProvider>,
+    );
+    expect(html).toContain("Hallo");
+    expect(html).not.toContain("Hello");
+  });
+
+  test(`renderToStaticMarkup via useOptionalTranslation resolves the resolver's locale, not "en"`, () => {
+    const resolver = createStaticLocaleResolver({ locale: "de" });
+    const bundles: TranslationsByLocale[] = [{ de: { greet: "Hallo" }, en: { greet: "Hello" } }];
+    function Probe(): ReactNode {
+      const t = useOptionalTranslation();
+      return <span>{t?.("greet")}</span>;
+    }
+    const html = renderToStaticMarkup(
+      <LocaleProvider resolver={resolver} fallbackBundles={bundles}>
+        <Probe />
+      </LocaleProvider>,
+    );
+    expect(html).toContain("Hallo");
+    expect(html).not.toContain("Hello");
+  });
+});

package/src/app/__tests__/entity-list-row-action-icon.test.tsx

@@ -0,0 +1,169 @@
+// fw-ui-defaults: RowAction had no icon field at all, so every framework-
+// generated action button rendered as a same-looking text button. This
+// renders the real entityList pipeline (KumikoScreen → EntityListBody) and
+// asserts on the resolved `icon` KumikoScreen attaches to each
+// DataTableRowAction — the id-derived default (ACTION_ICON_BY_ID in
+// kumiko-screen.tsx) for an action with no declared icon, and the declared
+// icon overriding that default for one that has it.
+
+import { describe, expect, test } from "bun:test";
+import type {
+  EntityDefinition,
+  EntityListScreenDefinition,
+} 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 { createStaticLocaleResolver, LocaleProvider } from "../../i18n";
+import { kumikoDefaultTranslations } from "../../i18n-defaults";
+import {
+  type CorePrimitives,
+  type DataTableProps,
+  type DataTableRowAction,
+  PrimitivesProvider,
+} from "../../primitives";
+import type { FeatureSchema } from "../feature-schema";
+import { KumikoScreen } from "../kumiko-screen";
+import { NavProvider } from "../nav";
+
+function stubDispatcher(): Dispatcher {
+  return {
+    write: (async () => ({ isSuccess: true, data: {} })) as unknown as Dispatcher["write"],
+    query: (async () => ({
+      isSuccess: true,
+      data: { rows: [{ id: "row-1" }], nextCursor: null, total: 1 },
+    })) 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: () => [],
+  };
+}
+
+let capturedRowActions: readonly DataTableRowAction[] | undefined;
+const captureDataTable: ComponentType<DataTableProps> = (props) => {
+  capturedRowActions = props.rowActions;
+  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 buildSchema(): FeatureSchema {
+  const entity: EntityDefinition = {
+    fields: {
+      name: { type: "text", maxLength: 50, required: false, searchable: false, sortable: false },
+    },
+  };
+  const listScreen: EntityListScreenDefinition = {
+    id: "widget-list",
+    type: "entityList",
+    entity: "widget",
+    columns: ["name"],
+    rowActions: [
+      // No declared icon — must fall back to ACTION_ICON_BY_ID["delete"].
+      {
+        id: "delete",
+        label: "Delete",
+        handler: "icon-fixture:write:widget:delete",
+      },
+      // Declared icon on an id that DOES have an id-derived default
+      // ("edit" -> pencil) — the declared icon must win.
+      {
+        kind: "navigate",
+        id: "edit",
+        label: "Edit",
+        screen: "widget-edit",
+        icon: "archive",
+      },
+    ],
+  };
+  return {
+    featureName: "icon-fixture",
+    entities: { widget: entity },
+    screens: [listScreen],
+  } as FeatureSchema;
+}
+
+function renderListScreen(): void {
+  render(
+    <LocaleProvider
+      resolver={createStaticLocaleResolver({ locale: "en" })}
+      fallbackBundles={[kumikoDefaultTranslations]}
+    >
+      <DispatcherProvider dispatcher={stubDispatcher()}>
+        <NavProvider
+          value={{
+            route: { screenId: "icon-fixture:screen:widget-list" },
+            navigate: () => {},
+            replace: () => {},
+            hrefFor: () => "",
+            searchParams: {},
+            setSearchParams: () => {},
+          }}
+        >
+          <PrimitivesProvider value={testPrimitives}>
+            <KumikoScreen schema={buildSchema()} qn="icon-fixture:screen:widget-list" />
+          </PrimitivesProvider>
+        </NavProvider>
+      </DispatcherProvider>
+    </LocaleProvider>,
+  );
+}
+
+function requireAction(id: string): DataTableRowAction {
+  const action = capturedRowActions?.find((a) => a.id === id);
+  if (!action) throw new Error(`expected the '${id}' row action to be captured`);
+  return action;
+}
+
+describe("entityList rowActions resolve an icon (fw-ui-defaults)", () => {
+  test("an action with no declared icon derives it from its id ('delete' -> trash)", async () => {
+    capturedRowActions = undefined;
+
+    renderListScreen();
+
+    await waitFor(() => {
+      expect(capturedRowActions).toBeDefined();
+    });
+
+    expect(requireAction("delete").icon).toBe("trash");
+  });
+
+  test("a declared icon overrides the id-derived default ('edit' would derive pencil)", async () => {
+    capturedRowActions = undefined;
+
+    renderListScreen();
+
+    await waitFor(() => {
+      expect(capturedRowActions).toBeDefined();
+    });
+
+    expect(requireAction("edit").icon).toBe("archive");
+  });
+});