@cosmicdrift/kumiko-headless 0.64.0 → 0.66.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-headless",
-  "version": "0.64.0",
+  "version": "0.66.0",
   "description": "Headless UI logic for Kumiko — Dispatcher contract, Form-Controller, View-Model, Nav-Resolver. Plattform- und React-frei; jeder Renderer (renderer, renderer-web, renderer-native, …) komponiert darauf.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -32,7 +32,7 @@
     }
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-framework": "0.57.2",
+    "@cosmicdrift/kumiko-framework": "0.66.0",
     "zod": "^4.4.3"
   },
   "publishConfig": {

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

@@ -199,4 +199,47 @@ describe("resolveNavigation", () => {
     expect(tree[0]?.children[0]?.qualifiedName).toBe("a:nav:mid");
     expect(tree[0]?.children[0]?.children[0]?.qualifiedName).toBe("a:nav:leaf");
   });
+
+  // Visual-Tree-Merge: die polymorphen Felder (target/actions/createAction/
+  // provider) müssen durch resolveNavigation durchgereicht werden, sonst
+  // kann der eine Renderer dynamische/dispatch-Knoten nicht bauen.
+  test("polymorphic fields pass through: target, actions, createAction, provider", () => {
+    const editTarget = { featureId: "text-content", action: "edit", args: { slug: "hero" } };
+    const createTarget = { featureId: "text-content", action: "create", args: { folder: "page" } };
+    const source = buildSource([
+      {
+        id: "tc:nav:content",
+        label: "Content",
+        provider: true,
+        createAction: { icon: "plus", label: "New page", target: createTarget },
+      },
+      {
+        id: "tc:nav:hero",
+        label: "Hero",
+        parent: "tc:nav:content",
+        target: editTarget,
+        actions: [{ icon: "trash", label: "Delete", target: editTarget }],
+      },
+    ]);
+
+    const tree = resolveNavigation({ source });
+    const content = tree[0];
+    expect(content?.provider).toBe(true);
+    expect(content?.createAction?.target).toEqual(createTarget);
+    const hero = content?.children[0];
+    expect(hero?.target).toEqual(editTarget);
+    expect(hero?.screen).toBeUndefined();
+    expect(hero?.actions).toHaveLength(1);
+  });
+
+  // Knoten ohne die neuen Felder dürfen sie NICHT als undefined-Keys tragen
+  // (conditional-spread): hält die resolved Node sauber + Snapshot-stabil.
+  test("absent polymorphic fields are omitted, not set to undefined", () => {
+    const source = buildSource([{ id: "a:nav:plain", label: "Plain", screen: "a:screen:x" }]);
+    const node = resolveNavigation({ source })[0];
+    expect(node).not.toBeUndefined();
+    expect("target" in (node ?? {})).toBe(false);
+    expect("provider" in (node ?? {})).toBe(false);
+    expect("actions" in (node ?? {})).toBe(false);
+  });
 });

package/src/nav/resolve.ts

@@ -31,6 +31,10 @@ export function resolveNavigation(options: ResolveNavigationOptions): NavTree {
       children,
       ...(entry.icon !== undefined && { icon: entry.icon }),
       ...(entry.screen !== undefined && { screen: entry.screen }),
+      ...(entry.target !== undefined && { target: entry.target }),
+      ...(entry.actions !== undefined && { actions: entry.actions }),
+      ...(entry.createAction !== undefined && { createAction: entry.createAction }),
+      ...(entry.provider !== undefined && { provider: entry.provider }),
     };
   }
 

package/src/nav/types.ts

@@ -1,4 +1,4 @@
-import type { NavDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { NavDefinition, TargetRef, TreeAction } from "@cosmicdrift/kumiko-framework/ui-types";
 
 // A single resolved nav entry as the renderer consumes it. Labels are NOT
 // translated yet — nav can be used in SSR contexts where the locale isn't
@@ -13,6 +13,15 @@ export type NavNode = {
   readonly label: string;
   readonly icon?: string;
   readonly screen?: string;
+  // Polymorphes Klick-Ziel (EditorPanel via dispatch) — Alternative zu
+  // `screen`. Knoten trägt screen XOR target.
+  readonly target?: TargetRef;
+  // Hover-Actions + „+"-Affordance, durchgereicht aus der NavDefinition.
+  readonly actions?: readonly TreeAction[];
+  readonly createAction?: TreeAction;
+  // true → Children kommen zur Laufzeit aus einem nav-provider (lazy +
+  // SSE-live), nicht aus `children`. Renderer macht den Knoten expandable.
+  readonly provider?: boolean;
   readonly order: number;
   readonly children: readonly NavNode[];
 };

package/src/view-model/edit.ts

@@ -119,6 +119,12 @@ export function computeEditViewModel<
         fieldDef.type === "reference"
           ? ((fieldDef as unknown as { multiple?: boolean }).multiple ?? false)
           : undefined;
+      // file/image: accept/maxSize ins ViewModel + entityType/fieldName für
+      // den Upload-POST (Endpoint validiert gegen die richtige Field-Def).
+      const isFileType = fieldDef.type === "file" || fieldDef.type === "image";
+      const fileDef = isFileType
+        ? (fieldDef as unknown as { accept?: readonly string[]; maxSize?: string })
+        : undefined;
       const view: EditFieldViewModel = {
         field: normalized.field,
         label,
@@ -140,12 +146,16 @@ export function computeEditViewModel<
         ...(refFeature !== undefined && { refFeature }),
         ...(refLabelField !== undefined && { refLabelField }),
         ...(refMultiple !== undefined && { refMultiple }),
+        ...(fileDef?.accept !== undefined && { accept: fileDef.accept }),
+        ...(fileDef?.maxSize !== undefined && { maxSize: fileDef.maxSize }),
+        ...(isFileType && { entityType: screen.entity, fieldName: normalized.field }),
       };
       return view;
     });
     return {
       kind: "fields" as const,
-      title: translate(sectionSpec.title),
+      // Titellose Section (flache Form) → kein h3; nur übersetzen wenn gesetzt.
+      ...(sectionSpec.title !== undefined && { title: translate(sectionSpec.title) }),
       columns: sectionSpec.columns ?? 1,
       fields,
     };

package/src/view-model/types.ts

@@ -132,6 +132,17 @@ export type EditFieldViewModel = {
   /** Nur bei `type: "reference"` — Multi-Mode (Tier 2.7e-Multi):
    *  Wert ist UUID-Array, Renderer mountet Multi-Combobox mit Tags. */
   readonly refMultiple?: boolean;
+  /** Nur bei `type: "file" | "image"` — erlaubte Extensions/MIME (z.B.
+   *  ["jpg","png"]) + Max-Größe ("5mb"). Der Renderer setzt das `accept`-
+   *  Attribut + zeigt die Grenze; die Validierung läuft serverseitig im
+   *  Upload-Endpoint gegen die Field-Def. */
+  readonly accept?: readonly string[];
+  readonly maxSize?: string;
+  /** Nur bei `type: "file" | "image"` — Entity-Name + Field-Name für den
+   *  Upload-POST (`/api/files`), damit der Endpoint maxSize/accept gegen
+   *  die richtige Field-Def prüfen kann. */
+  readonly entityType?: string;
+  readonly fieldName?: string;
 };
 
 // Discriminated by `kind` — mirrors EditSectionSpec on the engine side.
@@ -141,7 +152,8 @@ export type EditSectionViewModel = EditFieldsSectionViewModel | EditExtensionSec
 
 export type EditFieldsSectionViewModel = {
   readonly kind: "fields";
-  readonly title: string;
+  /** Optional — eine titellose Section rendert nur ihre Felder (flache Form). */
+  readonly title?: string;
   readonly columns: number;
   readonly fields: readonly EditFieldViewModel[];
 };