@cosmicdrift/kumiko-headless 0.328.0 → 0.328.1

package/src/view-model/embedded-list.ts

@@ -1,89 +0,0 @@
-import type { EmbeddedDerivedCellDef } from "@cosmicdrift/kumiko-framework/ui-types";
-import type { FieldIssue } from "../dispatcher";
-
-export type EmbeddedDerivedOp = EmbeddedDerivedCellDef["op"];
-
-export type { DerivedCellRoundingTarget } from "@cosmicdrift/kumiko-framework/ui-types";
-// Canonical implementation moved to packages/framework/src/engine/embedded-derived.ts
-// (the write-schema preprocess needs it server-side too).
-export {
-  computeDerivedCellValue,
-  roundDerivedCellValue,
-} from "@cosmicdrift/kumiko-framework/ui-types";
-
-/** Sums a numeric/money/decimal column across all rows. Non-numeric or
- *  missing values count as 0. Money columns are minor-unit integers —
- *  the sum stays in minor units, never rounds through a major-unit float. */
-export function sumEmbeddedListColumn(
-  rows: readonly Readonly<Record<string, unknown>>[],
-  field: string,
-): number {
-  let sum = 0;
-  for (const row of rows) {
-    const value = row[field];
-    if (typeof value === "number" && Number.isFinite(value)) sum += value;
-  }
-  return sum;
-}
-
-export type EmbeddedListIssueGroups = {
-  /** Issues at exactly `listField` — e.g. min/max row-count violations. */
-  readonly listIssues: readonly FieldIssue[];
-  /** Issues at exactly `${listField}.${rowIndex}` — a row-level check
-   *  (e.g. "row incomplete") that isn't attributable to one cell. */
-  readonly rowIssues: Readonly<Record<number, readonly FieldIssue[]>>;
-  /** Issues at exactly `${listField}.${rowIndex}.${cellField}`, keyed
-   *  `${rowIndex}.${cellField}` (not the full path — the caller already
-   *  knows listField). */
-  readonly cellIssues: Readonly<Record<string, readonly FieldIssue[]>>;
-};
-
-/** Buckets a flat issues-by-path map (FormSnapshot.errors shape — see
- *  packages/headless/src/form/zod-bridge.ts groupIssuesByPath) into the
- *  three levels an embedded-list widget renders. Only keys that are
- *  exactly `listField`, `listField.N`, or `listField.N.subfield` are
- *  claimed; unrelated keys (other top-level fields, or deeper nesting
- *  than this field ever produces) are ignored. */
-export function groupEmbeddedListIssues(
-  allIssues: Readonly<Record<string, readonly FieldIssue[]>>,
-  listField: string,
-): EmbeddedListIssueGroups {
-  const listIssues: FieldIssue[] = [];
-  const rowIssues: Record<number, readonly FieldIssue[]> = {};
-  const cellIssues: Record<string, readonly FieldIssue[]> = {};
-
-  const prefix = `${listField}.`;
-  for (const [path, issues] of Object.entries(allIssues)) {
-    if (path === listField) {
-      listIssues.push(...issues);
-      continue;
-    }
-    if (!path.startsWith(prefix)) continue;
-    const rest = path.slice(prefix.length);
-    const segments = rest.split(".");
-    if (segments.length === 1) {
-      const rowIndex = parsePureRowIndex(segments[0]);
-      if (rowIndex === undefined) continue;
-      rowIssues[rowIndex] = issues;
-      continue;
-    }
-    if (segments.length === 2) {
-      const rowIndex = parsePureRowIndex(segments[0]);
-      if (rowIndex === undefined) continue;
-      const cellField = segments[1];
-      cellIssues[`${rowIndex}.${cellField}`] = issues;
-    }
-    // Deeper than `listField.N.subfield` — not a shape this field ever
-    // produces; ignore rather than misattribute to a cell.
-  }
-
-  return { listIssues, rowIssues, cellIssues };
-}
-
-function parsePureRowIndex(segment: string | undefined): number | undefined {
-  if (segment === undefined || segment.length === 0) return undefined;
-  for (const char of segment) {
-    if (char < "0" || char > "9") return undefined;
-  }
-  return Number(segment);
-}

package/src/view-model/index.ts

@@ -1,43 +0,0 @@
-export type { ComputeEditViewModelInput } from "./edit";
-export { computeEditViewModel } from "./edit";
-export type {
-  DerivedCellRoundingTarget,
-  EmbeddedDerivedOp,
-  EmbeddedListIssueGroups,
-} from "./embedded-list";
-export {
-  computeDerivedCellValue,
-  groupEmbeddedListIssues,
-  roundDerivedCellValue,
-  sumEmbeddedListColumn,
-} from "./embedded-list";
-export type { ComputeListViewModelInput } from "./list";
-export {
-  computeListViewModel,
-  embeddedCellLabelKey,
-  embeddedCellOptionLabelKey,
-  fieldLabelKey,
-  fieldOptionLabelKey,
-  fieldOptionLabelKeyPrefix,
-} from "./list";
-export type {
-  EditExtensionSectionViewModel,
-  EditFieldSpec,
-  EditFieldsSectionViewModel,
-  EditFieldViewModel,
-  EditRelatedListSectionViewModel,
-  EditSectionSpec,
-  EditSectionViewModel,
-  EditViewModel,
-  EditWriteFormSectionViewModel,
-  EmbeddedListCellViewModel,
-  FieldConditionCtx,
-  FieldRenderer,
-  ListColumnSpec,
-  ListColumnViewModel,
-  ListRowViewModel,
-  ListViewModel,
-  RuntimeRenderer,
-  ScreenSlots,
-  Translate,
-} from "./types";

package/src/view-model/list.ts

@@ -1,280 +0,0 @@
-import type {
-  EntityDefinition,
-  EntityListScreenDefinition,
-  FieldDefinition,
-} from "@cosmicdrift/kumiko-framework/ui-types";
-import {
-  LIST_ROW_META_COLUMNS,
-  LIST_ROW_META_REFERENCES,
-  normalizeListColumn,
-  parseRefTarget,
-} from "@cosmicdrift/kumiko-framework/ui-types";
-import type { ListColumnViewModel, ListRowViewModel, ListViewModel, Translate } from "./types";
-
-export type ComputeListViewModelInput = {
-  readonly screen: EntityListScreenDefinition;
-  readonly entity: EntityDefinition;
-  readonly rows: readonly Readonly<Record<string, unknown>>[];
-  // Translate callback — normally LocaleResolver.translate. Labels use the
-  // i18n convention "{feature}:entity:{entityName}:field:{fieldName}"; if
-  // the key is absent from the active bundle, i18next falls back to the
-  // key itself, which is fine for dev.
-  readonly translate: Translate;
-  // Feature + entity name are required for i18n key composition —
-  // ScreenDefinition carries `entity: string` but not the feature scope,
-  // and i18n keys are prefixed by feature. Passed in by the caller (the
-  // renderer knows its host-feature context).
-  readonly featureName: string;
-};
-
-// Pure transform: takes the declared screen + entity + incoming rows, spits
-// out the flat shape the renderer draws. No conditions, no access-checks —
-// those are list-level decisions that the caller makes BEFORE calling
-// here (e.g. filtering rows by ownership on the server / before query).
-// Field-level read-access (Level 3 of UI-architecture.md §Permission) is a
-// follow-up; this v1 assumes the caller passed a row-filter that drops any
-// field the user may not see.
-export function computeListViewModel(input: ComputeListViewModelInput): ListViewModel {
-  const { screen, entity, rows, translate, featureName } = input;
-
-  const columns: ListColumnViewModel[] = [];
-  for (const spec of screen.columns) {
-    const normalized = normalizeListColumn(spec);
-    if (normalized.refEntity !== undefined) {
-      // Declared reference metadata (ListColumnSpec.refEntity) — for
-      // projectionList/relatedList columns, which have no EntityDefinition
-      // field to carry a real "reference" type. Checked before the
-      // entity.fields lookup below so it also fires against the pseudo-
-      // entities that hardcode every field as "text" (projection-list-shim,
-      // related-list-section) — those never reach the reference branch
-      // further down since fieldDef.type is always "text" there.
-      const refTarget = parseRefTarget(normalized.refEntity, featureName);
-      columns.push({
-        field: normalized.field,
-        label: translate(
-          normalized.label ?? fieldLabelKey(featureName, screen.entity, normalized.field),
-        ),
-        type: "reference",
-        // The declared value is the referenced id, not the resolved label —
-        // there is no column to server-sort by, same as row-meta references.
-        sortable: false,
-        refEntity: refTarget.entityName,
-        refFeature: refTarget.featureName,
-        refLabelField: normalized.refLabelField ?? "id",
-        ...(normalized.renderer !== undefined && { renderer: normalized.renderer }),
-      });
-      continue;
-    }
-    const fieldDef = entity.fields[normalized.field];
-    if (!fieldDef) {
-      // Not a stored field — may be a read-time derived field (value appended
-      // by the list-query handler). Render it as its display valueType; derived
-      // columns carry no reference/select metadata and never server-sort.
-      const derivedDef = entity.derivedFields?.[normalized.field];
-      if (!derivedDef) {
-        // Row-meta column (id/tenantId/version/insertedAt/modifiedAt/...) —
-        // a real base-table column that's never a declared entity field, e.g.
-        // a SystemAdmin cross-tenant list exposing tenantId. Unlike the
-        // derivedFields branch above, these are actual DB columns, so
-        // server-side ORDER BY works — sortable stays true, except for the
-        // ID columns in LIST_ROW_META_REFERENCES (see their reference branch).
-        const rowMetaType = LIST_ROW_META_COLUMNS[normalized.field];
-        if (rowMetaType !== undefined) {
-          const rowMetaRef = LIST_ROW_META_REFERENCES[normalized.field];
-          columns.push({
-            field: normalized.field,
-            label: translate(
-              normalized.label ?? fieldLabelKey(featureName, screen.entity, normalized.field),
-            ),
-            type: rowMetaRef !== undefined ? "reference" : rowMetaType,
-            // The DB column holds the GUID, not the resolved label — server-side
-            // ORDER BY would sort by GUID while the cell shows the name.
-            sortable: rowMetaRef === undefined,
-            ...(normalized.renderer !== undefined && { renderer: normalized.renderer }),
-            ...(rowMetaRef !== undefined && {
-              refEntity: rowMetaRef.refEntity,
-              refFeature: rowMetaRef.refFeature,
-              refLabelField: rowMetaRef.refLabelField,
-            }),
-          });
-          continue;
-        }
-        // A virtual presentational column — drawn entirely by a columnRenderer
-        // component from the row (e.g. tag chips); value is undefined and it
-        // never server-sorts. `field` is just the column key. It needs BOTH a
-        // label AND a renderer — renderer is what actually draws it; a label
-        // alone with no renderer would push an empty, unrendered column into
-        // the view model. Missing either is an author typo (or a stale
-        // field-rename) → fail loud instead of silently drawing nothing.
-        if (normalized.label !== undefined && normalized.renderer !== undefined) {
-          columns.push({
-            field: normalized.field,
-            label: translate(normalized.label),
-            type: "text",
-            sortable: false,
-            renderer: normalized.renderer,
-          });
-          continue;
-        }
-        throw new Error(
-          `computeListViewModel: screen "${screen.id}" references unknown field "${normalized.field}" on entity "${screen.entity}"`,
-        );
-      }
-      columns.push({
-        field: normalized.field,
-        label: translate(
-          normalized.label ?? fieldLabelKey(featureName, screen.entity, normalized.field),
-        ),
-        type: derivedDef.valueType,
-        // Display-only: a header sort would round-trip to the server, which has
-        // no column to sort by (see DerivedFieldDef). Never offer the affordance.
-        sortable: false,
-        ...(normalized.renderer !== undefined && { renderer: normalized.renderer }),
-      });
-      continue;
-    }
-    const label = translate(
-      normalized.label ?? fieldLabelKey(featureName, screen.entity, normalized.field),
-    );
-    // Tier 2.7e-3 + Cross-Feature: Reference-Field — entity-String
-    // kann same-feature ("user") oder cross-feature ("users:user")
-    // sein. parseRefTarget gibt (featureName, entityName), der
-    // Renderer baut die Lookup-QN als
-    // `<refFeature>:query:<refEntity>:list`.
-    const refRaw =
-      fieldDef.type === "reference"
-        ? (fieldDef as unknown as { entity?: string }).entity
-        : undefined;
-    const refTarget = refRaw !== undefined ? parseRefTarget(refRaw, featureName) : undefined;
-    const refEntity = refTarget?.entityName;
-    const refFeature = refTarget?.featureName;
-    const refLabelField =
-      fieldDef.type === "reference"
-        ? ((fieldDef as unknown as { labelField?: string }).labelField ?? "id")
-        : undefined;
-    // For select and multiSelect fields: bake in translated option labels.
-    // Convention matches the form path → one translation source for list +
-    // form. A missing key returns the key itself per convention; the
-    // renderer then falls back to humanizeSlug.
-    const optionLabels =
-      fieldDef.type === "select" || fieldDef.type === "multiSelect"
-        ? buildOptionLabels(
-            translate,
-            (value) => fieldOptionLabelKey(featureName, screen.entity, normalized.field, value),
-            (fieldDef as unknown as { options?: readonly string[] }).options ?? [],
-          )
-        : undefined;
-    const optionTones = fieldDef.type === "select" ? fieldDef.optionTones : undefined;
-    const grouping = fieldDef.type === "number" ? fieldDef.grouping : undefined;
-    const column: ListColumnViewModel = {
-      field: normalized.field,
-      label,
-      type: fieldDef.type,
-      sortable: fieldIsSortable(fieldDef),
-      ...(normalized.renderer !== undefined && { renderer: normalized.renderer }),
-      ...(optionLabels !== undefined && { optionLabels }),
-      ...(optionTones !== undefined && { optionTones }),
-      ...(refEntity !== undefined && { refEntity }),
-      ...(refFeature !== undefined && { refFeature }),
-      ...(refLabelField !== undefined && { refLabelField }),
-      ...(grouping !== undefined && { grouping }),
-      ...(normalized.hideOnNarrow === true && { hideOnNarrow: true }),
-    };
-    columns.push(column);
-  }
-
-  const listRows: ListRowViewModel[] = rows.map((row) => ({
-    id: String(row["id"] ?? ""),
-    values: row,
-  }));
-
-  return {
-    screenId: screen.id,
-    entityName: screen.entity,
-    columns,
-    rows: listRows,
-    ...(screen.slots && { slots: screen.slots }),
-    isEmpty: listRows.length === 0,
-  };
-}
-
-// Field-i18n-key convention matches what features register translations
-// under (see packages/framework/src/i18n/ for the pattern). Duplicated
-// here as a plain function — the ui-core boundary forbids depending on
-// the i18n module directly.
-export function fieldLabelKey(featureName: string, entityName: string, fieldName: string): string {
-  return `${featureName}:entity:${entityName}:field:${fieldName}`;
-}
-
-export function fieldOptionLabelKeyPrefix(
-  featureName: string,
-  entityName: string,
-  fieldName: string,
-): string {
-  return `${fieldLabelKey(featureName, entityName, fieldName)}:option:`;
-}
-
-export function fieldOptionLabelKey(
-  featureName: string,
-  entityName: string,
-  fieldName: string,
-  value: string,
-): string {
-  return `${fieldOptionLabelKeyPrefix(featureName, entityName, fieldName)}${value}`;
-}
-
-// Embedded-list cell label key — one level deeper than fieldLabelKey,
-// keyed by the sub-field name inside an embedded-LIST field's `schema`
-// (invoice-positions-style tables built via createEmbeddedListField()).
-export function embeddedCellLabelKey(
-  featureName: string,
-  entityName: string,
-  fieldName: string,
-  subFieldName: string,
-): string {
-  return `${featureName}:entity:${entityName}:field:${fieldName}:cell:${subFieldName}`;
-}
-
-export function embeddedCellOptionLabelKey(
-  featureName: string,
-  entityName: string,
-  fieldName: string,
-  subFieldName: string,
-  value: string,
-): string {
-  return `${featureName}:entity:${entityName}:field:${fieldName}:cell:${subFieldName}:option:${value}`;
-}
-
-// Build a value→label map for a select-field's options. Convention:
-// translate() returns the input key when the lookup misses (i18next
-// default + LocaleResolver convention) — we surface the *raw value* in
-// that case so the renderer's humanizeSlug fallback can take over.
-// Without that fallback, an unlabeled option would render as the full
-// `feature:entity:field:option:value`-key.
-//
-// `keyFor` carries whichever key convention the caller needs (top-level
-// field via fieldOptionLabelKey, embedded-list cell via
-// embeddedCellOptionLabelKey) — shared between list-VM, edit-VM, and
-// embedded-list cells so all three produce identical option-translations.
-export function buildOptionLabels(
-  translate: (key: string, params?: Readonly<Record<string, unknown>>) => string,
-  keyFor: (value: string) => string,
-  options: readonly string[],
-): Readonly<Record<string, string>> {
-  const out: Record<string, string> = {};
-  for (const value of options) {
-    const key = keyFor(value);
-    const translated = translate(key);
-    out[value] = translated === key ? value : translated;
-  }
-  return out;
-}
-
-// A field can declare `sortable: true` on the FieldDefinition. This is
-// framework-level metadata used both by the server's list-query builder
-// (ORDER BY safety) and by the UI (column header click indicator). All
-// field types can bear the flag; it's off by default.
-function fieldIsSortable(field: FieldDefinition): boolean {
-  const flag = (field as unknown as { sortable?: boolean }).sortable;
-  return flag === true;
-}