@cosmicdrift/kumiko-renderer 0.32.1 → 0.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-renderer",
-  "version": "0.32.1",
+  "version": "0.34.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/kumiko-screen.tsx

@@ -5,8 +5,10 @@ import type {
   EntityDefinition,
   EntityEditScreenDefinition,
   EntityListScreenDefinition,
+  FieldCondition,
   RowAction,
   RowActionWriteHandler,
+  RowFieldExtractor,
   ScreenDefinition,
   ToolbarAction,
 } from "@cosmicdrift/kumiko-framework/ui-types";
@@ -34,6 +36,23 @@ import { useNav } from "./nav";
 import { lastSegment } from "./qn";
 import { dispatcherErrorText, WriteFailedError } from "./write-failed-error";
 
+function evalRowExtractor(
+  extractor: RowFieldExtractor,
+  row: Record<string, unknown>,
+): Record<string, unknown> {
+  if ("pick" in extractor) {
+    return Object.fromEntries(extractor.pick.map((f) => [f, row[f]]));
+  }
+  return Object.fromEntries(Object.entries(extractor.map).map(([to, from]) => [to, row[from]]));
+}
+
+function evalFieldCondition(cond: FieldCondition, values: Record<string, unknown>): boolean {
+  if (typeof cond === "boolean") return cond;
+  const val = values[cond.field];
+  if ("eq" in cond) return val === cond.eq;
+  return val !== cond.ne;
+}
+
 // KumikoScreen picks up a ScreenDefinition from the schema by qn and
 // routes it to the right renderer based on `screen.type`. Command
 // qualification (`<feature>:write:<entity>:create` etc.) happens here
@@ -659,11 +678,8 @@ function EntityListBody({
         // navigate-Variante braucht keinen Dispatcher; nav ist
         // immer da (Provider von createKumikoApp).
         if (action.kind === "navigate") {
-          // Deklarativer entityId-Default: zielt die Action auf einen
-          // entityEdit-Screen, ist row.id die entityId. Nötig weil die
-          // Function-Form (action.entityId) JSON-injizierte Schemas
-          // (window.__KUMIKO_SCHEMA__) nicht überlebt — silent gedroppt,
-          // siehe RowAction-Type-Header.
+          // Default entityId für entityEdit-Targets: row["id"] wenn
+          // kein expliziter entityId-Feldname gesetzt ist.
           const targetIsEntityEdit = schema.screens.some(
             (s) => s.type === "entityEdit" && lastSegment(s.id) === action.screen,
           );
@@ -672,14 +688,20 @@ function EntityListBody({
             label: effectiveTranslate(action.label),
             ...(action.style !== undefined && { style: action.style }),
             onTrigger: (row: ListRowViewModel) => {
-              const explicit = action.entityId?.(row.values);
+              const explicit =
+                action.entityId !== undefined
+                  ? String(row.values[action.entityId] ?? "")
+                  : undefined;
               const fallback = targetIsEntityEdit ? String(row.values["id"] ?? "") : undefined;
               const entityId = explicit ?? fallback;
               nav.navigate({
                 screenId: action.screen,
                 ...(entityId !== undefined && entityId !== "" && { entityId }),
               });
-              const params = action.params?.(row.values);
+              const params =
+                action.params !== undefined
+                  ? evalRowExtractor(action.params, row.values)
+                  : undefined;
               if (params !== undefined) {
                 // setSearchParams nimmt string|null. Komplexe Werte
                 // (number/boolean) wandeln wir zu String — der Reader
@@ -696,7 +718,7 @@ function EntityListBody({
               }
             },
             ...(action.visible !== undefined && {
-              isVisible: (row: ListRowViewModel) => action.visible?.(row.values, undefined) ?? true,
+              isVisible: (row: ListRowViewModel) => evalFieldCondition(action.visible!, row.values),
             }),
           };
         }
@@ -716,7 +738,9 @@ function EntityListBody({
           onTrigger: async (row: ListRowViewModel) => {
             const buildPayload = writeAction.payload;
             const payload =
-              buildPayload !== undefined ? buildPayload(row.values) : { id: row.values["id"] };
+              buildPayload !== undefined
+                ? evalRowExtractor(buildPayload, row.values)
+                : { id: row.values["id"] };
             const result = await dispatcher.write(writeAction.handler, payload);
             // write() wirft nicht — Failure-Result MUSS hier zum Error
             // werden, sonst schließt der Confirm-Dialog kommentarlos und
@@ -730,7 +754,7 @@ function EntityListBody({
           },
           isVisible:
             writeAction.visible !== undefined
-              ? (row: ListRowViewModel) => writeAction.visible?.(row.values, undefined) ?? true
+              ? (row: ListRowViewModel) => evalFieldCondition(writeAction.visible!, row.values)
               : undefined,
         };
       })
@@ -766,7 +790,7 @@ function EntityListBody({
             confirmLabel: effectiveTranslate(action.confirmLabel),
           }),
           onTrigger: async () => {
-            const payload = action.payload?.() ?? {};
+            const payload = action.payload ?? {};
             await dispatcher.write(action.handler, payload);
           },
         };

package/src/components/render-edit.tsx

@@ -1,6 +1,7 @@
 import type {
   EntityDefinition,
   EntityEditScreenDefinition,
+  FieldCondition,
 } from "@cosmicdrift/kumiko-framework/ui-types";
 import { isExtensionEditSection, normalizeEditField } from "@cosmicdrift/kumiko-framework/ui-types";
 import type {
@@ -64,6 +65,18 @@ export type RenderEditProps<TValues extends FormValues, TCtx = unknown> = {
   readonly fieldAppendix?: (fieldName: string) => ReactNode | undefined;
 };
 
+function toConditionValue<TValues extends FormValues, TCtx>(
+  cond: FieldCondition,
+): NonNullable<FieldConditions<TValues, TCtx>["visible"]> {
+  if (typeof cond === "boolean") return cond;
+  if ("eq" in cond) {
+    const { field, eq } = cond;
+    return (values: TValues) => (values as Record<string, unknown>)[field] === eq;
+  }
+  const { field, ne } = cond;
+  return (values: TValues) => (values as Record<string, unknown>)[field] !== ne;
+}
+
 function deriveFormFields<TValues extends FormValues, TCtx>(
   screen: EntityEditScreenDefinition,
 ): Record<string, FieldConditions<TValues, TCtx>> {
@@ -74,13 +87,13 @@ function deriveFormFields<TValues extends FormValues, TCtx>(
       const normalized = normalizeEditField(spec);
       out[normalized.field] = {
         ...(normalized.visible !== undefined && {
-          visible: normalized.visible as FieldConditions<TValues, TCtx>["visible"],
+          visible: toConditionValue<TValues, TCtx>(normalized.visible),
         }),
         ...(normalized.readOnly !== undefined && {
-          readonly: normalized.readOnly as FieldConditions<TValues, TCtx>["readonly"],
+          readonly: toConditionValue<TValues, TCtx>(normalized.readOnly),
         }),
         ...(normalized.required !== undefined && {
-          required: normalized.required as FieldConditions<TValues, TCtx>["required"],
+          required: toConditionValue<TValues, TCtx>(normalized.required),
         }),
       };
     }
@@ -195,9 +208,8 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
         values: snapshot.values,
         translate,
         featureName,
-        ctx,
       }),
-    [screen, entity, snapshot.values, translate, featureName, ctx],
+    [screen, entity, snapshot.values, translate, featureName],
   );
 
   async function handleSubmit(): Promise<void> {