@cosmicdrift/kumiko-renderer 0.157.2 → 0.159.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-renderer",
-  "version": "0.157.2",
+  "version": "0.159.1",
   "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.157.2",
-    "@cosmicdrift/kumiko-headless": "0.157.2",
+    "@cosmicdrift/kumiko-framework": "0.159.1",
+    "@cosmicdrift/kumiko-headless": "0.159.1",
     "react": "^19.2.6",
     "temporal-polyfill": "^0.3.2"
   },

package/src/__tests__/sort-by-accessor.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+import { sortByAccessor } from "../sort-by-accessor";
+
+type Row = { readonly name: string; readonly count: number };
+
+const rows: readonly Row[] = [
+  { name: "b", count: 2 },
+  { name: "a", count: 3 },
+  { name: "c", count: 1 },
+];
+
+const accessors = {
+  name: (r: Row) => r.name,
+  count: (r: Row) => r.count,
+};
+
+describe("sortByAccessor", () => {
+  test("sort === null returns rows unchanged (same reference)", () => {
+    expect(sortByAccessor(rows, null, accessors)).toBe(rows);
+  });
+
+  test("an unknown field returns rows unchanged (same reference)", () => {
+    expect(sortByAccessor(rows, { field: "nope", dir: "asc" }, accessors)).toBe(rows);
+  });
+
+  test("sorts ascending by the given accessor", () => {
+    const sorted = sortByAccessor(rows, { field: "name", dir: "asc" }, accessors);
+    expect(sorted.map((r) => r.name)).toEqual(["a", "b", "c"]);
+  });
+
+  test("sorts descending by the given accessor", () => {
+    const sorted = sortByAccessor(rows, { field: "count", dir: "desc" }, accessors);
+    expect(sorted.map((r) => r.count)).toEqual([3, 2, 1]);
+  });
+
+  test("does not mutate the input array", () => {
+    const original = [...rows];
+    sortByAccessor(rows, { field: "name", dir: "asc" }, accessors);
+    expect(rows).toEqual(original);
+  });
+});

package/src/app/__tests__/config-edit-shim.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from "bun:test";
+import type { ConfigEditScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import { synthesizeConfigEditEntity, synthesizeConfigEditScreen } from "../config-edit-shim";
+
+describe("synthesizeConfigEditEntity", () => {
+  test("wraps the inline fields as an EntityDefinition", () => {
+    const fields = { apiKey: { type: "text" } } as unknown as ConfigEditScreenDefinition["fields"];
+    expect(synthesizeConfigEditEntity(fields)).toEqual({ fields });
+  });
+});
+
+describe("synthesizeConfigEditScreen", () => {
+  test("stamps type: entityEdit and a pseudo entity name", () => {
+    const screen = {
+      id: "settings",
+      layout: { sections: [] },
+    } as unknown as ConfigEditScreenDefinition;
+
+    const result = synthesizeConfigEditScreen(screen);
+    expect(result.id).toBe("settings");
+    expect(result.type).toBe("entityEdit");
+    expect(result.entity).toBe("__config-edit__");
+    expect(result.layout).toBe(screen.layout);
+    expect(result).not.toHaveProperty("fieldLabels");
+    expect(result).not.toHaveProperty("access");
+  });
+
+  test("carries fieldLabels and access through when present", () => {
+    const screen = {
+      id: "settings",
+      layout: { sections: [] },
+      fieldLabels: { apiKey: "config.apiKey" },
+      access: { roles: ["Admin"] },
+    } as unknown as ConfigEditScreenDefinition;
+
+    const result = synthesizeConfigEditScreen(screen);
+    expect(result.fieldLabels).toEqual({ apiKey: "config.apiKey" });
+    expect(result.access).toEqual({ roles: ["Admin"] });
+  });
+});

package/src/app/__tests__/screen-access-allows.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "bun:test";
+import { screenAccessAllows } from "../kumiko-screen";
+
+describe("screenAccessAllows", () => {
+  test("allows when no access rule is set", () => {
+    expect(screenAccessAllows(undefined, undefined)).toBe(true);
+  });
+
+  test("openToAll: true allows regardless of roles", () => {
+    expect(screenAccessAllows({ openToAll: true }, undefined)).toBe(true);
+  });
+
+  test("roles-gated allows a matching role", () => {
+    expect(screenAccessAllows({ roles: ["Admin"] }, ["Admin"])).toBe(true);
+  });
+
+  test("roles-gated denies with no matching role", () => {
+    expect(screenAccessAllows({ roles: ["Admin"] }, ["Member"])).toBe(false);
+  });
+
+  test("roles-gated denies when userRoles is undefined", () => {
+    expect(screenAccessAllows({ roles: ["Admin"] }, undefined)).toBe(false);
+  });
+});

package/src/app/kumiko-screen.tsx

@@ -120,7 +120,7 @@ export function qualifyNavId(featureName: string, navId: string): string {
 // Duplicated instead of imported from framework/engine's hasAccess (pulls
 // server-side deps) — same bundle-purity reasoning as headless/nav's
 // resolve.ts:userCanSee, which this mirrors.
-function screenAccessAllows(
+export function screenAccessAllows(
   access: AccessRule | undefined,
   userRoles: readonly string[] | undefined,
 ): boolean {