@cosmicdrift/kumiko-renderer 0.25.0 → 0.27.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-renderer",
-  "version": "0.25.0",
+  "version": "0.27.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>",

package/src/app/__tests__/feature-schema.test.ts

@@ -0,0 +1,31 @@
+// feature-schema Pure-Logik Tests (Phase 1, test-luecken-integration, Tier 1).
+//
+// toAppSchema normalisiert FeatureSchema → AppSchema (idempotent),
+// isAppSchema diskriminiert die beiden Formen. Zero source-change.
+
+import { describe, expect, test } from "bun:test";
+import type { AppSchema, FeatureSchema } from "@cosmicdrift/kumiko-framework/ui-types";
+import { isAppSchema, toAppSchema } from "../feature-schema";
+
+const feature: FeatureSchema = { featureName: "tasks", entities: {}, screens: [] };
+
+describe("toAppSchema", () => {
+  test("wraps a FeatureSchema into the AppSchema envelope", () => {
+    const app = toAppSchema(feature);
+    expect(app.features).toHaveLength(1);
+    expect(app.features[0]?.featureName).toBe("tasks");
+    expect(app.workspaces).toBeUndefined();
+  });
+
+  test("idempotent for AppSchema input (returns the same reference)", () => {
+    const app: AppSchema = { features: [feature] };
+    expect(toAppSchema(app)).toBe(app);
+  });
+});
+
+describe("isAppSchema", () => {
+  test("true for AppSchema (has 'features'), false for FeatureSchema", () => {
+    expect(isAppSchema({ features: [feature] })).toBe(true);
+    expect(isAppSchema(feature)).toBe(false);
+  });
+});

package/src/app/__tests__/nav.test.ts

@@ -0,0 +1,83 @@
+// nav Pure-Logik Tests (Phase 1, test-luecken-integration, Tier 1).
+//
+// parsePath/formatPath: plattform-neutrale URL-Grammatik mit zwei Modi
+// (mit/ohne Workspaces). Pure, kein DOM.
+
+import { describe, expect, test } from "bun:test";
+import { formatPath, parsePath } from "../nav";
+
+describe("parsePath — ohne Workspaces", () => {
+  test("/<screenId>", () => {
+    expect(parsePath("/task-list")).toEqual({ screenId: "task-list" });
+  });
+
+  test("/<screenId>/<entityId>", () => {
+    expect(parsePath("/task-edit/abc-123")).toEqual({ screenId: "task-edit", entityId: "abc-123" });
+  });
+
+  test("Root und leerer Pfad → undefined", () => {
+    expect(parsePath("/")).toBeUndefined();
+    expect(parsePath("")).toBeUndefined();
+  });
+
+  test("überzählige Segmente werden ignoriert (kein Nesting)", () => {
+    expect(parsePath("/a/b/c/d")).toEqual({ screenId: "a", entityId: "b" });
+  });
+});
+
+describe("parsePath — mit Workspaces (hasWorkspaces=true)", () => {
+  test("/<workspaceId>/<screenId>", () => {
+    expect(parsePath("/admin/task-list", true)).toEqual({
+      workspaceId: "admin",
+      screenId: "task-list",
+    });
+  });
+
+  test("/<workspaceId>/<screenId>/<entityId>", () => {
+    expect(parsePath("/admin/task-edit/abc", true)).toEqual({
+      workspaceId: "admin",
+      screenId: "task-edit",
+      entityId: "abc",
+    });
+  });
+
+  test("Workspace-only /<workspaceId> → leerer screenId (Shell resolved Default)", () => {
+    expect(parsePath("/admin", true)).toEqual({ workspaceId: "admin", screenId: "" });
+  });
+
+  test("Root / → undefined", () => {
+    expect(parsePath("/", true)).toBeUndefined();
+  });
+});
+
+describe("formatPath", () => {
+  test("flach: /<screenId>", () => {
+    expect(formatPath({ screenId: "task-list" })).toBe("/task-list");
+  });
+
+  test("mit entityId", () => {
+    expect(formatPath({ screenId: "task-edit", entityId: "abc" })).toBe("/task-edit/abc");
+  });
+
+  test("mit workspaceId-Prefix", () => {
+    expect(formatPath({ workspaceId: "admin", screenId: "task-list" })).toBe("/admin/task-list");
+  });
+
+  test("workspace + entity", () => {
+    expect(formatPath({ workspaceId: "admin", screenId: "task-edit", entityId: "abc" })).toBe(
+      "/admin/task-edit/abc",
+    );
+  });
+});
+
+describe("Roundtrip parsePath ↔ formatPath", () => {
+  test("non-workspace", () => {
+    const t = { screenId: "task-edit", entityId: "abc" };
+    expect(parsePath(formatPath(t))).toEqual(t);
+  });
+
+  test("workspace", () => {
+    const t = { workspaceId: "admin", screenId: "task-edit", entityId: "abc" };
+    expect(parsePath(formatPath(t), true)).toEqual(t);
+  });
+});

package/src/app/__tests__/qualified-names.test.ts

@@ -0,0 +1,37 @@
+// Qualified-Name Pure-Logik Tests (Phase 1, test-luecken-integration, Tier 1).
+//
+// lastSegment (qn.ts) ist die Inverse von qualifyScreenId/qualifyNavId
+// (kumiko-screen.tsx) — Schema speichert QN-Form, der Renderer/die URL
+// nutzt Short-Form. Roundtrip pinnt diese Symmetrie.
+
+import { describe, expect, test } from "bun:test";
+import { qualifyNavId, qualifyScreenId } from "../kumiko-screen";
+import { lastSegment } from "../qn";
+
+describe("lastSegment", () => {
+  test("nimmt den letzten ':'-getrennten Teil", () => {
+    expect(lastSegment("tasks:screen:task-list")).toBe("task-list");
+    expect(lastSegment("a:b")).toBe("b");
+  });
+
+  test("String ohne ':' bleibt unverändert (Short-Form passt durch)", () => {
+    expect(lastSegment("task-list")).toBe("task-list");
+    expect(lastSegment("")).toBe("");
+  });
+
+  test("trailing ':' → leerer Suffix", () => {
+    expect(lastSegment("a:")).toBe("");
+  });
+});
+
+describe("qualifyScreenId / qualifyNavId", () => {
+  test("baut featureName:screen:id bzw. featureName:nav:id", () => {
+    expect(qualifyScreenId("tasks", "task-list")).toBe("tasks:screen:task-list");
+    expect(qualifyNavId("tasks", "main")).toBe("tasks:nav:main");
+  });
+
+  test("lastSegment ist die Inverse von qualify*", () => {
+    expect(lastSegment(qualifyScreenId("tasks", "task-list"))).toBe("task-list");
+    expect(lastSegment(qualifyNavId("tasks", "main"))).toBe("main");
+  });
+});

package/src/components/__tests__/render-field-app-locale.test.tsx

@@ -0,0 +1,77 @@
+// Regression: RenderField muss das App-Locale (useLocale) an money-/date-
+// Inputs durchreichen — auch ohne explizites field.locale. Vorher fielen
+// die Inputs auf navigator.language (Browser-Sprache) statt der per
+// LocaleProvider gewählten App-Sprache zurück → Separator-Mismatch.
+//
+// Capture-Input statt echter Primitive: hält den Test renderer-intern
+// (relativer Import von RenderField → diese Source), unabhängig davon
+// wie @cosmicdrift/* im Workspace aufgelöst wird.
+
+import { describe, expect, test } from "bun:test";
+import type { EditFieldViewModel } from "@cosmicdrift/kumiko-headless";
+import { render } from "@testing-library/react";
+import type { ComponentType, ReactNode } from "react";
+import { createStaticLocaleResolver, LocaleProvider } from "../../i18n";
+import { type CorePrimitives, type InputProps, PrimitivesProvider } from "../../primitives";
+import { RenderField } from "../render-field";
+
+let captured: InputProps | undefined;
+const captureInput: ComponentType<InputProps> = (props) => {
+  captured = props;
+  return null;
+};
+const noop = (): ReactNode => null;
+const passChildren = ({ children }: { readonly children?: ReactNode }): ReactNode => children;
+
+const testPrimitives: CorePrimitives = {
+  Button: noop,
+  Banner: noop,
+  Field: passChildren,
+  Input: captureInput,
+  DataTable: noop,
+  Form: noop,
+  Section: noop,
+  Grid: noop,
+  GridCell: noop,
+  Text: noop,
+  Heading: noop,
+  Dialog: noop,
+  ConfigSourceBadge: noop,
+  ConfigCascadeView: noop,
+};
+
+function moneyField(): EditFieldViewModel {
+  return {
+    field: "price",
+    label: "Preis",
+    type: "money",
+    value: 123456,
+    visible: true,
+    readOnly: false,
+    required: false,
+  };
+}
+
+function renderUnderLocale(locale: string): void {
+  captured = undefined;
+  render(
+    <LocaleProvider resolver={createStaticLocaleResolver({ locale })}>
+      <PrimitivesProvider value={testPrimitives}>
+        <RenderField field={moneyField()} onChange={() => {}} />
+      </PrimitivesProvider>
+    </LocaleProvider>,
+  );
+}
+
+describe("RenderField — App-Locale an money durchreichen", () => {
+  test("money ohne field.locale bekommt das App-Locale (de-DE)", () => {
+    renderUnderLocale("de-DE");
+    expect(captured?.kind).toBe("money");
+    if (captured?.kind === "money") expect(captured.locale).toBe("de-DE");
+  });
+
+  test("ein anderes App-Locale wird ebenso durchgereicht (en-US)", () => {
+    renderUnderLocale("en-US");
+    if (captured?.kind === "money") expect(captured.locale).toBe("en-US");
+  });
+});

package/src/components/render-field.tsx

@@ -2,6 +2,7 @@ import type { EditFieldViewModel, FieldIssue } from "@cosmicdrift/kumiko-headles
 import { type ReactNode, useCallback, useMemo, useState } from "react";
 import { REFERENCE_COMBOBOX_LIMIT } from "../hooks/reference-limits";
 import { useQuery } from "../hooks/use-query";
+import { useLocale } from "../i18n";
 import { usePrimitives } from "../primitives";
 
 // RenderField übersetzt ein EditFieldViewModel → Primitives-Baum.
@@ -36,6 +37,11 @@ export function RenderField({
   fieldAppendix,
 }: RenderFieldProps): ReactNode {
   const { Field, Input } = usePrimitives();
+  // App-Locale (i18n) für money/date-Inputs — sonst fielen sie auf
+  // navigator.language (Browser-Sprache) zurück statt der gewählten
+  // App-Sprache. useLocale() wirft ohne LocaleProvider; ok, weil
+  // RenderField nur unter RenderEdit im Kumiko-App-Tree läuft.
+  const appLocale = useLocale().locale();
   if (!field.visible) return null;
 
   const id = inputId(field);
@@ -55,7 +61,7 @@ export function RenderField({
         featureName={featureName ?? ""}
       />
     ) : (
-      renderInput({ field, id, hasError, onChange, Input })
+      renderInput({ field, id, hasError, onChange, Input, appLocale })
     );
 
   return (
@@ -189,12 +195,14 @@ function renderInput({
   hasError,
   onChange,
   Input,
+  appLocale,
 }: {
   readonly field: EditFieldViewModel;
   readonly id: string;
   readonly hasError: boolean;
   readonly onChange: (value: unknown) => void;
   readonly Input: ReturnType<typeof usePrimitives>["Input"];
+  readonly appLocale: string;
 }): ReactNode {
   const common = {
     id,
@@ -223,7 +231,7 @@ function renderInput({
           value={numberValue(field.value)}
           onChange={(v) => onChange(v)}
           {...(moneyDef.currency !== undefined && { currency: moneyDef.currency })}
-          {...(moneyDef.locale !== undefined && { locale: moneyDef.locale })}
+          locale={moneyDef.locale ?? appLocale}
         />
       );
     }
@@ -243,6 +251,7 @@ function renderInput({
           {...common}
           value={stringValue(field.value)}
           onChange={(v) => onChange(v)}
+          locale={appLocale}
         />
       );
     case "timestamp":