@cosmicdrift/kumiko-headless 0.238.0 → 0.240.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-headless",
-  "version": "0.238.0",
+  "version": "0.240.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>",
@@ -36,7 +36,7 @@
     }
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-framework": "0.238.0",
+    "@cosmicdrift/kumiko-framework": "0.240.0",
     "temporal-polyfill": "^0.3.2",
     "zod": "^4.4.3"
   },

package/src/index.ts

@@ -89,6 +89,7 @@ export type {
   EditSectionSpec,
   EditSectionViewModel,
   EditViewModel,
+  EditWriteFormSectionViewModel,
   EmbeddedDerivedOp,
   EmbeddedListCellViewModel,
   EmbeddedListIssueGroups,

package/src/view-model/__tests__/edit.test.ts

@@ -2,9 +2,15 @@ import { describe, expect, test } from "bun:test";
 import type {
   EntityDefinition,
   EntityEditScreenDefinition,
+  RowAction,
 } from "@cosmicdrift/kumiko-framework/ui-types";
 import { computeEditViewModel } from "../edit";
-import type { EditFieldsSectionViewModel, EditSectionViewModel } from "../types";
+import type {
+  EditFieldsSectionViewModel,
+  EditRelatedListSectionViewModel,
+  EditSectionViewModel,
+  EditWriteFormSectionViewModel,
+} from "../types";
 
 function asFields(s: EditSectionViewModel | undefined): EditFieldsSectionViewModel {
   if (s === undefined || s.kind !== "fields") {
@@ -730,3 +736,150 @@ describe("computeEditViewModel — declared reference metadata (fw#2662)", () =>
     expect(field?.refLabelField).toBeUndefined();
   });
 });
+
+function asRelatedList(s: EditSectionViewModel | undefined): EditRelatedListSectionViewModel {
+  if (s === undefined || s.kind !== "relatedList") {
+    throw new Error(`expected relatedList-section, got ${s?.kind ?? "undefined"}`);
+  }
+  return s;
+}
+
+function asWriteForm(s: EditSectionViewModel | undefined): EditWriteFormSectionViewModel {
+  if (s === undefined || s.kind !== "writeForm") {
+    throw new Error(`expected writeForm-section, got ${s?.kind ?? "undefined"}`);
+  }
+  return s;
+}
+
+describe("computeEditViewModel — relatedList rowActions passthrough (fw editable-detail-screens)", () => {
+  test("rowActions pass through onto the relatedList section view-model verbatim", () => {
+    const rowActions: readonly RowAction[] = [
+      { id: "sync", label: "actions.sync", handler: "app:write:sync", payload: { pick: ["id"] } },
+    ];
+    const vm = computeEditViewModel({
+      screen: editScreen({
+        sections: [
+          {
+            kind: "relatedList",
+            title: "History",
+            query: "app:query:history",
+            columns: ["name"],
+            rowActions,
+          },
+        ],
+      }),
+      entity: orderEntity,
+      values: {},
+      translate,
+      featureName: "orders",
+    });
+
+    expect(asRelatedList(vm.sections[0]).rowActions).toEqual(rowActions);
+  });
+
+  test("rowActions is absent from the view-model when the section spec has none", () => {
+    const vm = computeEditViewModel({
+      screen: editScreen({
+        sections: [
+          { kind: "relatedList", title: "History", query: "app:query:history", columns: ["name"] },
+        ],
+      }),
+      entity: orderEntity,
+      values: {},
+      translate,
+      featureName: "orders",
+    });
+
+    expect(asRelatedList(vm.sections[0]).rowActions).toBeUndefined();
+  });
+});
+
+describe("computeEditViewModel — writeForm sections (fw editable-detail-screens)", () => {
+  test("resolves the section's own fieldDefs/fields through the same per-field pipeline as a fields section", () => {
+    const vm = computeEditViewModel({
+      screen: editScreen({
+        sections: [
+          {
+            kind: "writeForm",
+            title: "Add note",
+            fieldDefs: { note: { type: "text", required: true } },
+            fields: ["note"],
+            handler: "orders:write:add-note",
+          },
+        ],
+      }),
+      entity: orderEntity,
+      values: {},
+      translate,
+      featureName: "orders",
+    });
+
+    const section = asWriteForm(vm.sections[0]);
+    expect(section.handler).toBe("orders:write:add-note");
+    expect(section.fields).toEqual([
+      {
+        field: "note",
+        label: "orders:entity:__write-form-section__:field:note",
+        type: "text",
+        value: undefined,
+        visible: true,
+        readOnly: false,
+        required: true,
+      },
+    ]);
+  });
+
+  test("readOnly/required on a writeForm field come from the section's own fieldDefs, independent of the host entity", () => {
+    const vm = computeEditViewModel({
+      screen: editScreen({
+        sections: [
+          {
+            kind: "writeForm",
+            title: "Add note",
+            // "notes" is optional on orderEntity — the writeForm section's own
+            // fieldDefs declares its own "notes" field as required, and that
+            // (not the host entity's) must win.
+            fieldDefs: { notes: { type: "text", required: true } },
+            fields: ["notes"],
+            handler: "orders:write:add-note",
+          },
+        ],
+      }),
+      entity: orderEntity,
+      values: {},
+      translate,
+      featureName: "orders",
+    });
+
+    expect(asWriteForm(vm.sections[0]).fields[0]?.required).toBe(true);
+  });
+
+  test("columns defaults to 1; icon/description/submitLabel are translated and passed through when set", () => {
+    const vm = computeEditViewModel({
+      screen: editScreen({
+        sections: [
+          {
+            kind: "writeForm",
+            title: "Add note",
+            description: "orders:write-form.description",
+            icon: "plus",
+            fieldDefs: { note: { type: "text" } },
+            fields: ["note"],
+            handler: "orders:write:add-note",
+            submitLabel: "orders:write-form.submit",
+          },
+        ],
+      }),
+      entity: orderEntity,
+      values: {},
+      translate,
+      featureName: "orders",
+    });
+
+    const section = asWriteForm(vm.sections[0]);
+    expect(section.columns).toBe(1);
+    expect(section.icon).toBe("plus");
+    expect(section.description).toBe("orders:write-form.description");
+    expect(section.submitLabel).toBe("orders:write-form.submit");
+  });
+});

package/src/view-model/edit.ts

@@ -1,4 +1,5 @@
 import type {
+  EditWriteFormSection,
   EntityDefinition,
   EntityEditScreenDefinition,
   FieldCondition,
@@ -7,8 +8,10 @@ import {
   evalFieldCondition,
   isExtensionEditSection,
   isFieldsEditSection,
+  isWriteFormEditSection,
   normalizeEditField,
   parseRefTarget,
+  WRITE_FORM_SECTION_ENTITY,
 } from "@cosmicdrift/kumiko-framework/ui-types";
 import {
   buildOptionLabels,
@@ -21,6 +24,7 @@ import type {
   EditFieldViewModel,
   EditSectionViewModel,
   EditViewModel,
+  EditWriteFormSectionViewModel,
   EmbeddedListCellViewModel,
   Translate,
 } from "./types";
@@ -58,6 +62,54 @@ export type ComputeEditViewModelInput<
   readonly featureName: string;
 };
 
+// Resolves a writeForm section's own fieldDefs/fields through the same
+// per-field pipeline as a plain fields section, by reusing the pipeline
+// itself rather than duplicating it: wrap fieldDefs/fields as a throwaway
+// entityEdit screen (same "synthesize a pseudo-entity" idiom as the shims in
+// packages/renderer/src/app/*-shim.ts) and recurse into computeEditViewModel
+// once. Split out of computeEditViewModel's section-map to keep that
+// function's own complexity from absorbing this branch's decision points.
+function computeWriteFormSectionViewModel<TValues extends Readonly<Record<string, unknown>>>(
+  sectionSpec: EditWriteFormSection,
+  screenId: string,
+  values: TValues,
+  translate: Translate,
+  featureName: string,
+): EditWriteFormSectionViewModel {
+  const innerEntity: EntityDefinition = { fields: sectionSpec.fieldDefs } as EntityDefinition;
+  const innerScreen: EntityEditScreenDefinition = {
+    id: `${screenId}:${sectionSpec.id ?? "write-form"}`,
+    type: "entityEdit",
+    entity: WRITE_FORM_SECTION_ENTITY,
+    layout: {
+      sections: [{ kind: "fields", fields: sectionSpec.fields, columns: sectionSpec.columns }],
+    },
+  };
+  const inner = computeEditViewModel({
+    screen: innerScreen,
+    entity: innerEntity,
+    values,
+    translate,
+    featureName,
+  });
+  const innerSection = inner.sections[0];
+  const fields = innerSection?.kind === "fields" ? innerSection.fields : [];
+  return {
+    kind: "writeForm" as const,
+    ...(sectionSpec.title !== undefined && { title: translate(sectionSpec.title) }),
+    ...(sectionSpec.description !== undefined && {
+      description: translate(sectionSpec.description),
+    }),
+    columns: sectionSpec.columns ?? 1,
+    fields,
+    ...(sectionSpec.icon !== undefined && { icon: sectionSpec.icon }),
+    handler: sectionSpec.handler,
+    ...(sectionSpec.submitLabel !== undefined && {
+      submitLabel: translate(sectionSpec.submitLabel),
+    }),
+  };
+}
+
 // Pure transform from screen-def + entity-def + row-values to the flat
 // section/field tree the renderer draws. FieldConditions are evaluated here
 // so the renderer never re-runs them during React render.
@@ -76,6 +128,15 @@ export function computeEditViewModel<
         ...(sectionSpec.entityName !== undefined && { entityName: sectionSpec.entityName }),
       };
     }
+    if (isWriteFormEditSection(sectionSpec)) {
+      return computeWriteFormSectionViewModel(
+        sectionSpec,
+        screen.id,
+        values,
+        translate,
+        featureName,
+      );
+    }
     if (!isFieldsEditSection(sectionSpec)) {
       // relatedList runs its own query — nothing here to resolve against
       // entity/values, the spec passes through verbatim (fw#2166).
@@ -87,6 +148,7 @@ export function computeEditViewModel<
         columns: sectionSpec.columns,
         ...(sectionSpec.pageSize !== undefined && { pageSize: sectionSpec.pageSize }),
         ...(sectionSpec.rowClick !== undefined && { rowClick: sectionSpec.rowClick }),
+        ...(sectionSpec.rowActions !== undefined && { rowActions: sectionSpec.rowActions }),
       };
     }
     const fields: EditFieldViewModel[] = sectionSpec.fields.map((fieldSpec) => {

package/src/view-model/index.ts

@@ -29,6 +29,7 @@ export type {
   EditSectionSpec,
   EditSectionViewModel,
   EditViewModel,
+  EditWriteFormSectionViewModel,
   EmbeddedListCellViewModel,
   FieldConditionCtx,
   FieldRenderer,

package/src/view-model/types.ts

@@ -6,6 +6,7 @@ import type {
   IconKey,
   ListColumnSpec,
   PlatformComponent,
+  RowAction,
   ScreenSlots,
 } from "@cosmicdrift/kumiko-framework/ui-types";
 
@@ -247,7 +248,8 @@ export type EditFieldViewModel = {
 export type EditSectionViewModel =
   | EditFieldsSectionViewModel
   | EditExtensionSectionViewModel
-  | EditRelatedListSectionViewModel;
+  | EditRelatedListSectionViewModel
+  | EditWriteFormSectionViewModel;
 
 export type EditFieldsSectionViewModel = {
   readonly kind: "fields";
@@ -287,6 +289,22 @@ export type EditRelatedListSectionViewModel = {
   readonly columns: readonly ListColumnSpec[];
   readonly pageSize?: number;
   readonly rowClick?: { readonly entity: string; readonly idColumn?: string };
+  readonly rowActions?: readonly RowAction[];
+};
+
+// Mirrors EditWriteFormSection, except `fields` is already resolved through
+// the same per-field pipeline as EditFieldsSectionViewModel (computed via a
+// recursive computeEditViewModel call against the section's own fieldDefs —
+// see edit.ts) — the renderer needs no second field-resolution path.
+export type EditWriteFormSectionViewModel = {
+  readonly kind: "writeForm";
+  readonly title?: string;
+  readonly description?: string;
+  readonly columns: number;
+  readonly fields: readonly EditFieldViewModel[];
+  readonly icon?: IconKey;
+  readonly handler: string;
+  readonly submitLabel?: string;
 };
 
 export type EditViewModel = {