@cosmicdrift/kumiko-headless 0.33.0 → 0.34.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-headless",
-  "version": "0.33.0",
+  "version": "0.34.1",
   "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>",

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

@@ -102,9 +102,8 @@ describe("computeEditViewModel", () => {
             "vatExempt",
             {
               field: "vatReason",
-              // Only visible when VAT is exempt.
-              visible: (data) => (data as { vatExempt?: boolean }).vatExempt === true,
-              required: (data) => (data as { vatExempt?: boolean }).vatExempt === true,
+              visible: { field: "vatExempt", eq: true },
+              required: { field: "vatExempt", eq: true },
             },
           ],
         },
@@ -134,40 +133,33 @@ describe("computeEditViewModel", () => {
     expect(reasonShown?.required).toBe(true);
   });
 
-  test("readonly predicate receives ctx and evaluates per snapshot", () => {
+  test("readonly condition { field, ne } evaluates against form values", () => {
     const screen = editScreen({
       sections: [
         {
           title: "x",
-          fields: [
-            {
-              field: "customerName",
-              readOnly: (_d, ctx) => (ctx as { isAdmin: boolean }).isAdmin === false,
-            },
-          ],
+          fields: [{ field: "customerName", readOnly: { field: "isEditable", ne: true } }],
         },
       ],
     });
 
-    const nonAdmin = computeEditViewModel({
+    const locked = computeEditViewModel({
       screen,
       entity: orderEntity,
-      values: { customerName: "A" },
-      ctx: { isAdmin: false },
+      values: { customerName: "A", isEditable: false },
       translate,
       featureName: "orders",
     });
-    expect(asFields(nonAdmin.sections[0]).fields[0]?.readOnly).toBe(true);
+    expect(asFields(locked.sections[0]).fields[0]?.readOnly).toBe(true);
 
-    const admin = computeEditViewModel({
+    const editable = computeEditViewModel({
       screen,
       entity: orderEntity,
-      values: { customerName: "A" },
-      ctx: { isAdmin: true },
+      values: { customerName: "A", isEditable: true },
       translate,
       featureName: "orders",
     });
-    expect(asFields(admin.sections[0]).fields[0]?.readOnly).toBe(false);
+    expect(asFields(editable.sections[0]).fields[0]?.readOnly).toBe(false);
   });
 
   test("screen-level required override wins over entity-level required", () => {
@@ -178,7 +170,7 @@ describe("computeEditViewModel", () => {
         sections: [
           {
             title: "x",
-            fields: [{ field: "customerName", required: () => false }],
+            fields: [{ field: "customerName", required: false }],
           },
         ],
       }),

package/src/view-model/edit.ts

@@ -13,31 +13,21 @@ import type { EditFieldViewModel, EditSectionViewModel, EditViewModel, Translate
 
 export type ComputeEditViewModelInput<
   TValues extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>,
-  TCtx = unknown,
 > = {
   readonly screen: EntityEditScreenDefinition;
   readonly entity: EntityDefinition;
   readonly values: TValues;
   readonly translate: Translate;
   readonly featureName: string;
-  // Optional condition context — forwarded to field visible/readonly/required
-  // predicates. Normally the host app passes `{ user, config, ... }`.
-  readonly ctx?: TCtx;
 };
 
 // Pure transform from screen-def + entity-def + row-values to the flat
-// section/field tree the renderer draws. Conditional predicates are
-// evaluated here so the renderer never re-runs them during React render.
-//
-// TValues / TCtx are propagated through evalCondition so call-sites can
-// `computeEditViewModel<OrderRow, AdminCtx>(...)` and get typed data/ctx
-// inside their predicates. Default `unknown` keeps unannotated call-sites
-// working unchanged.
+// section/field tree the renderer draws. FieldConditions are evaluated here
+// so the renderer never re-runs them during React render.
 export function computeEditViewModel<
   TValues extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>,
-  TCtx = unknown,
->(input: ComputeEditViewModelInput<TValues, TCtx>): EditViewModel {
-  const { screen, entity, values, translate, featureName, ctx } = input;
+>(input: ComputeEditViewModelInput<TValues>): EditViewModel {
+  const { screen, entity, values, translate, featureName } = input;
 
   const sections: EditSectionViewModel[] = screen.layout.sections.map((sectionSpec) => {
     if (isExtensionEditSection(sectionSpec)) {
@@ -56,22 +46,17 @@ export function computeEditViewModel<
         );
       }
       const label = translate(fieldLabelKey(featureName, screen.entity, normalized.field));
-      const visible = evalCondition<TValues, TCtx>(normalized.visible, true, values, ctx);
+      const visible = evalCondition(normalized.visible, true, values);
       // `readOnly` (camelCase) is the name on both sides: EditFieldSpec
       // in the engine, and the view-model emitted here. One convention
       // through the stack beats translating at the boundary.
-      const readOnly = evalCondition<TValues, TCtx>(normalized.readOnly, false, values, ctx);
+      const readOnly = evalCondition(normalized.readOnly, false, values);
       // `required` on the field-spec overrides the entity-default. A
       // field that's required at the entity-level but marked required:
       // false on the screen (e.g. a soft-onboarding wizard that
       // collects less up-front) respects the screen override.
       const entityRequired = (fieldDef as unknown as { required?: boolean }).required === true;
-      const required = evalCondition<TValues, TCtx>(
-        normalized.required,
-        entityRequired,
-        values,
-        ctx,
-      );
+      const required = evalCondition(normalized.required, entityRequired, values);
       // Select-Optionen bei `type: "select"` mitnehmen — der Renderer
       // braucht sie für das Dropdown ohne nochmal die EntityDefinition
       // zu reichen. Plus translated Labels (gleiche Convention wie der
@@ -153,24 +138,16 @@ export function computeEditViewModel<
   };
 }
 
-// Resolves a FieldCondition (undefined | predicate) into its boolean
-// value against the current row values + ctx. `undefined` means "not
-// declared" — caller substitutes the entity-level default.
-//
-// TValues / TCtx mirror the generics on FieldCondition. EditFieldSpec
-// stores predicates as FieldCondition<unknown, unknown>, which is
-// assignable to FieldCondition<TValues, TCtx> for any TValues/TCtx by
-// parameter contravariance (a predicate that accepts `unknown` accepts
-// anything). The cast on ctx is the one rough edge: input.ctx is
-// optional, so at runtime we may pass undefined to a predicate that
-// declared a concrete TCtx — the caller is responsible for not doing
-// that when they narrow TCtx away from `unknown`.
-function evalCondition<TValues, TCtx>(
-  condition: FieldCondition<TValues, TCtx> | undefined,
+// Resolves a FieldCondition against the current row values.
+// `undefined` means "not declared" — caller substitutes the default.
+function evalCondition<TValues>(
+  condition: FieldCondition | undefined,
   fallback: boolean,
   values: TValues,
-  ctx: TCtx | undefined,
 ): boolean {
   if (condition === undefined) return fallback;
-  return condition(values, ctx as TCtx);
+  if (typeof condition === "boolean") return condition;
+  const val = (values as Record<string, unknown>)[condition.field];
+  if ("eq" in condition) return val === condition.eq;
+  return val !== condition.ne;
 }