@cosmicdrift/kumiko-renderer 0.327.0 → 0.328.1

package/src/components/related-list-section.tsx

@@ -1,467 +0,0 @@
-import type {
-  EntityDefinition,
-  EntityListScreenDefinition,
-  RowActionDrawer,
-  RowActionNavigate,
-} from "@cosmicdrift/kumiko-framework/ui-types";
-import { normalizeListColumn } from "@cosmicdrift/kumiko-framework/ui-types";
-import type {
-  EditRelatedListSectionViewModel,
-  ListRowViewModel,
-  Translate,
-} from "@cosmicdrift/kumiko-headless";
-import { type ReactNode, useCallback, useMemo, useState } from "react";
-import { useAppFeatures } from "../app/app-features-context";
-import {
-  buildFilterFacets,
-  buildFilterPayload,
-  mergeReferenceFacetOptions,
-  resolveProjectionFacetSpecs,
-} from "../app/list-facets";
-import { useNav } from "../app/nav";
-import { ReferenceFacetBridges, type ReferenceFacetOption } from "../app/reference-facet-bridge";
-import { navigateWithReturnTo, useReturnHost } from "../app/return-to";
-import {
-  buildDefaultEditRowAction,
-  buildProjectionRowActions,
-  buildProjectionToolbarActions,
-  buildRecordActions,
-  runProjectionRowNavigate,
-} from "../app/row-actions";
-import { findEditScreenFor } from "../app/screen-access";
-import { dispatcherErrorText } from "../app/write-failed-error";
-import { useOptionalDispatcher } from "../context/dispatcher-context";
-import { useUserRoles } from "../context/user-roles-context";
-import type { ListSort } from "../hooks/use-list-url-state";
-import { useQuery } from "../hooks/use-query";
-import { useTranslation } from "../i18n";
-import { type DataTableFacet, usePrimitives } from "../primitives";
-import { sortByAccessor } from "../sort-by-accessor";
-import { RenderEditActionButton } from "./render-edit-action-button";
-import { RenderList } from "./render-list";
-
-const RELATED_LIST_PSEUDO_ENTITY = "__related-list__";
-
-// Same paged envelope as ProjectionListBody's PagedRows (kumiko-screen.tsx) —
-// duplicated locally because that type isn't exported (projectionList and
-// relatedList are independent query call-sites, not a shared abstraction).
-type PagedRows = {
-  readonly rows: Readonly<Record<string, unknown>>[];
-  readonly nextCursor: string | null;
-  readonly total?: number;
-};
-
-// Minimal EntityDefinition from the section's own columns — same shape as
-// projection-list-shim's synthesizeProjectionEntity, but sortable is read
-// per-column (ListColumnSpec.sortable) instead of screen-wide, since a
-// relatedList section has no single Zod schema to derive it from.
-function synthesizeRelatedListEntity(
-  columns: EditRelatedListSectionViewModel["columns"],
-): EntityDefinition {
-  const fields: Record<string, { type: "text"; sortable: boolean }> = {};
-  for (const col of columns) {
-    const normalized = normalizeListColumn(col);
-    fields[normalized.field] = { type: "text", sortable: normalized.sortable === true };
-  }
-  return { fields } as unknown as EntityDefinition;
-}
-
-// Mirrors row-actions.ts's own warnDrawerActionDropped (module-private
-// there, so not reusable directly) — a drawer-kind emptyState.action with no
-// onOpenDrawer wired is dropped (not rendered) with a dev warning, same as a
-// drawer-kind rowAction/toolbarAction without one.
-function warnRelatedListEmptyStateDrawerDropped(actionId: string): void {
-  // biome-ignore lint/suspicious/noConsole: dev-time warning, same pattern as row-actions.ts
-  console.warn(
-    `[kumiko] relatedList emptyState.action "${actionId}" is kind: "drawer" but no onOpenDrawer was supplied — dropped.`,
-  );
-}
-
-export function RelatedListSection({
-  section,
-  parentId,
-  record,
-  featureName,
-  translate,
-  hideTitle,
-  onOpenDrawer,
-  actions,
-}: {
-  readonly section: EditRelatedListSectionViewModel;
-  readonly parentId: string;
-  /** The enclosing projectionDetail's own record (the "Akte") — evaluates
-   *  toolbarActions' `visible`/`params` (RelatedListToolbarAction), the same
-   *  record header actions already use. */
-  readonly record: Readonly<Record<string, unknown>>;
-  readonly featureName: string;
-  readonly translate?: Translate;
-  readonly hideTitle?: boolean;
-  /** Opens a drawer-kind rowAction (fw#2710). Supplied by the parent
-   *  (ProjectionDetailBody), which owns schema + the actual Drawer render —
-   *  this component only ever invokes the callback. */
-  readonly onOpenDrawer?: (
-    action: RowActionDrawer,
-    initialValues: Readonly<Record<string, unknown>> | undefined,
-  ) => void;
-  /** section.actions, already resolved into buttons by the caller —
-   *  rendered in the Section's title row. Only reachable in the standalone
-   *  (non-`hideTitle`) branch below — `hideTitle` uses `FillContainer`, which
-   *  has no title row to render actions into (see the comment on that branch). */
-  readonly actions?: ReactNode;
-}): ReactNode {
-  const { Banner, Section, FillContainer, Text, Button, Dialog } = usePrimitives();
-  const [emptyStateActionError, setEmptyStateActionError] = useState<string | null>(null);
-  const t = useTranslation();
-  const effectiveTranslate = translate ?? t;
-  const nav = useNav();
-  const host = useReturnHost();
-  const dispatcher = useOptionalDispatcher();
-  const appFeatures = useAppFeatures();
-  const userRoles = useUserRoles();
-  const defaultEditScreen = useMemo(() => {
-    const targetEntity = section.rowClick?.entity;
-    if (targetEntity === undefined) return undefined;
-    return findEditScreenFor(targetEntity, appFeatures, userRoles);
-  }, [appFeatures, section.rowClick, userRoles]);
-  const defaultEditRowAction = useMemo(
-    () => buildDefaultEditRowAction(defaultEditScreen, section.rowClick?.idColumn ?? "id"),
-    [defaultEditScreen, section.rowClick],
-  );
-
-  const entity = useMemo(() => synthesizeRelatedListEntity(section.columns), [section.columns]);
-  const listScreen = useMemo(
-    (): EntityListScreenDefinition => ({
-      // Empty id → RenderList's own toolbarTitle resolves to "" (its
-      // `screen:${id}.title` lookup misses and falls back to `id`) — this
-      // component renders the visible heading itself via `Section` below,
-      // so RenderList's toolbar carries none.
-      id: "",
-      type: "entityList",
-      entity: RELATED_LIST_PSEUDO_ENTITY,
-      columns: section.columns,
-    }),
-    [section.columns],
-  );
-
-  // Local state, not URL state: a section `id` is optional, so there is no
-  // stable URL key to namespace against — the section's sort is local for the
-  // same reason. Consequence: search/filters reset on reload.
-  const [search, setSearch] = useState("");
-  const [filters, setFilters] = useState<Readonly<Record<string, readonly string[]>>>({});
-
-  const facetSpecs = useMemo(
-    () => resolveProjectionFacetSpecs(section.facets, effectiveTranslate, featureName),
-    [section.facets, effectiveTranslate, featureName],
-  );
-  const [referenceFacetOptions, setReferenceFacetOptions] = useState<
-    Record<string, readonly ReferenceFacetOption[]>
-  >({});
-  const handleFacetOptions = useCallback(
-    (field: string, options: readonly ReferenceFacetOption[]) =>
-      setReferenceFacetOptions((prev) =>
-        prev[field] === options ? prev : { ...prev, [field]: options },
-      ),
-    [],
-  );
-  const resolvedFacetSpecs = useMemo(
-    () => mergeReferenceFacetOptions(facetSpecs, referenceFacetOptions),
-    [facetSpecs, referenceFacetOptions],
-  );
-  const filterPayload = useMemo(
-    () =>
-      buildFilterPayload(
-        filters,
-        (field) => resolvedFacetSpecs.find((spec) => spec.field === field)?.type,
-      ),
-    [filters, resolvedFacetSpecs],
-  );
-  const filterFacets = useMemo<DataTableFacet[]>(
-    () => buildFilterFacets(resolvedFacetSpecs),
-    [resolvedFacetSpecs],
-  );
-
-  const payload = useMemo(
-    () => ({
-      // `parentFilter` sends the parent id as a server-side `filter` clause
-      // instead of a bespoke top-level key — the generic `<entity>:list`
-      // query understands `filter`, not an arbitrary `parentParam` key. Kept
-      // separate from `filterPayload` (user facets) below so a facet
-      // selection can never clear or overwrite it.
-      ...(section.parentFilter !== undefined
-        ? { filter: { field: section.parentFilter.field, op: "eq" as const, value: parentId } }
-        : { [section.parentParam ?? "id"]: parentId }),
-      ...(section.pageSize !== undefined && { limit: section.pageSize }),
-      // Gated on the declared capability, not just on state carrying a value —
-      // same rule as ProjectionListBody: a param the bound query's Zod schema
-      // doesn't accept would 422 the whole section.
-      ...(section.searchable === true && search !== "" && { search }),
-      ...(section.facets !== undefined && filterPayload.length > 0 && { filters: filterPayload }),
-    }),
-    [
-      section.parentFilter,
-      section.parentParam,
-      section.pageSize,
-      section.searchable,
-      section.facets,
-      parentId,
-      search,
-      filterPayload,
-    ],
-  );
-
-  const rowsQuery = useQuery<PagedRows>(section.query, payload);
-
-  const onFilterChange = useCallback(
-    (field: string, values: readonly string[]) =>
-      setFilters((prev) => ({ ...prev, [field]: values })),
-    [],
-  );
-  const onFilterReset = useCallback(() => setFilters({}), []);
-
-  // Sorted client-side over the already-loaded rows — this section has no
-  // pager (see `payload` above: a one-shot fetch, no cursor/offset), so the
-  // loaded set already IS the full display set and there is no "other page"
-  // a client-side sort could misleadingly hide (fw#2722).
-  const [sort, setSort] = useState<ListSort | null>(section.defaultSort ?? null);
-  const sortAccessors = useMemo(() => {
-    const accessors: Record<string, (row: Readonly<Record<string, unknown>>) => string | number> =
-      {};
-    for (const col of section.columns) {
-      const field = normalizeListColumn(col).field;
-      accessors[field] = (row) => {
-        const value = row[field];
-        return typeof value === "number" ? value : String(value ?? "");
-      };
-    }
-    return accessors;
-  }, [section.columns]);
-  const sortedRows = useMemo(
-    () => sortByAccessor(rowsQuery.data?.rows ?? [], sort, sortAccessors),
-    [rowsQuery.data, sort, sortAccessors],
-  );
-
-  const rowClick = section.rowClick;
-  // A row-body click target comes from EITHER the legacy `rowClick` field OR
-  // a `rowActions` entry marked rowClick:true — the boot-validator rejects
-  // both being set, so this order is just a fallback, not a precedence rule.
-  const rowClickAction = section.rowActions?.find(
-    (a): a is RowActionNavigate => a.kind === "navigate" && a.rowClick === true,
-  );
-  const onRowClick =
-    rowClick !== undefined
-      ? (row: ListRowViewModel) => {
-          const id = String(row.values[rowClick.idColumn ?? "id"] ?? "");
-          if (id === "") return;
-          navigateWithReturnTo(nav, { entity: rowClick.entity, id }, host);
-        }
-      : rowClickAction !== undefined
-        ? (row: ListRowViewModel) => runProjectionRowNavigate(nav, rowClickAction, row, host)
-        : undefined;
-
-  // Same execution path as projectionList's rowActions (kumiko-screen.tsx) —
-  // a relatedList row has the identical "no guaranteed id field" shape a
-  // query-projection row has, so navigate/writeHandler dispatch is shared
-  // rather than a second implementation (fw editable-detail-screens).
-  const rowActions = useMemo(
-    () =>
-      buildProjectionRowActions({
-        rowActions: section.rowActions,
-        translate: effectiveTranslate,
-        dispatcher,
-        nav,
-        refetch: rowsQuery.refetch,
-        openDrawer: onOpenDrawer,
-        defaultEditRowAction,
-        host,
-      }),
-    [
-      section.rowActions,
-      effectiveTranslate,
-      dispatcher,
-      nav,
-      rowsQuery.refetch,
-      onOpenDrawer,
-      defaultEditRowAction,
-      host,
-    ],
-  );
-
-  // Toolbar actions (e.g. "+ Create" above the tab table) — same schema
-  // and dispatch semantics as entityList/projectionList.
-  const toolbarActionButtons = useMemo(
-    () =>
-      buildProjectionToolbarActions({
-        toolbarActions: section.toolbarActions,
-        translate: effectiveTranslate,
-        dispatcher,
-        nav,
-        refetch: rowsQuery.refetch,
-        navigatePrefill:
-          section.parentFilter !== undefined
-            ? { [section.parentFilter.field]: parentId }
-            : { [section.parentParam ?? "id"]: parentId },
-        record,
-        host,
-        ...(onOpenDrawer !== undefined && {
-          openDrawer: (action) => onOpenDrawer(action, undefined),
-        }),
-      }),
-    [
-      section.toolbarActions,
-      section.parentParam,
-      section.parentFilter,
-      parentId,
-      record,
-      effectiveTranslate,
-      dispatcher,
-      nav,
-      host,
-      rowsQuery.refetch,
-      onOpenDrawer,
-    ],
-  );
-
-  // emptyState.action is a RowAction — the same record-bound action shape
-  // (and evalRowExtractor payload/params evaluation) screen-level and
-  // section-level actions already use via buildRecordActions, NOT the
-  // toolbar-action builder (whose `payload` is a literal Record, not a
-  // RowFieldExtractor — casting a RowAction into it would silently skip the
-  // declared `pick`/`map` evaluation). "Row" here is the parent record: a
-  // relatedList's emptyState has no row of its own.
-  const emptyStateActionButton = useMemo(() => {
-    const action = section.emptyState?.action;
-    if (action === undefined) return undefined;
-    if (action.kind === "drawer" && onOpenDrawer === undefined) {
-      warnRelatedListEmptyStateDrawerDropped(action.id);
-      return undefined;
-    }
-    return buildRecordActions({
-      actions: [action],
-      record,
-      translate: effectiveTranslate,
-      nav,
-      host,
-      dispatcher,
-      openDrawer: onOpenDrawer ?? (() => {}),
-      onWriteSuccess: rowsQuery.refetch,
-    })?.[0];
-  }, [
-    section.emptyState,
-    record,
-    effectiveTranslate,
-    nav,
-    host,
-    dispatcher,
-    onOpenDrawer,
-    rowsQuery.refetch,
-  ]);
-  const emptyStateContent =
-    section.emptyState !== undefined ? (
-      <>
-        <Text>{section.emptyState.title}</Text>
-        {section.emptyState.description !== undefined && (
-          <Text variant="small">{section.emptyState.description}</Text>
-        )}
-        {emptyStateActionButton !== undefined && (
-          <RenderEditActionButton
-            action={emptyStateActionButton}
-            Button={Button}
-            Dialog={Dialog}
-            onError={setEmptyStateActionError}
-          />
-        )}
-      </>
-    ) : undefined;
-
-  // A truncated fetch means `sortedRows` is a sort of a partial set, not of
-  // the full related-row set — the client-side sort above (or even plain
-  // unsorted display) would silently claim "these are the top N" when they
-  // are really just "the first N in the server's own order" (fw#2722 review).
-  // `nextCursor` is exactly how the paged envelope marks that: non-null means
-  // more rows exist server-side beyond what was fetched.
-  const truncated = rowsQuery.data !== null && rowsQuery.data.nextCursor !== null;
-
-  const content =
-    rowsQuery.loading && rowsQuery.data === null ? (
-      <Banner padded variant="loading" testId="related-list-loading">
-        Loading…
-      </Banner>
-    ) : rowsQuery.error ? (
-      <Banner padded variant="error" testId="related-list-error">
-        {dispatcherErrorText(rowsQuery.error, effectiveTranslate)}
-      </Banner>
-    ) : (
-      <>
-        {truncated && (
-          <Banner variant="info" testId="related-list-truncated">
-            {effectiveTranslate("kumiko.list.related-list-truncated", {
-              count: sortedRows.length,
-            })}
-          </Banner>
-        )}
-        {emptyStateActionError !== null && (
-          <Banner variant="error" testId="related-list-empty-state-action-error">
-            {emptyStateActionError}
-          </Banner>
-        )}
-        <RenderList
-          screen={listScreen}
-          entity={entity}
-          rows={sortedRows}
-          featureName={featureName}
-          translate={effectiveTranslate}
-          sort={sort}
-          onSortChange={setSort}
-          {...(section.searchable === true && {
-            searchable: true,
-            searchValue: search,
-            onSearchChange: setSearch,
-          })}
-          {...(filterFacets.length > 0 && {
-            filterFacets,
-            filterValues: filters,
-            onFilterChange,
-            onFilterReset,
-          })}
-          {...(onRowClick !== undefined && { onRowClick })}
-          {...(rowActions !== undefined && { rowActions })}
-          {...(toolbarActionButtons !== undefined && { toolbarActions: toolbarActionButtons })}
-          {...(emptyStateContent !== undefined && { emptyState: emptyStateContent })}
-          {...(hideTitle === true && { scrollBody: true, screenPadding: false, chromeless: true })}
-        />
-      </>
-    );
-
-  // hideTitle (tabs mode) → the caller (render-edit.tsx) already wraps this
-  // component's own return value in the same Card frame every other tab
-  // kind gets — no card here, or the two would nest. `scrollBody` caps the
-  // table to the panel height; `FillContainer` is this section's link in the
-  // fillHeight flex chain that Card's `options.fillHeight` continues (see
-  // render-edit.tsx). A platform primitive (not a raw `<div>`) because
-  // `renderer` stays DOM-free. Stacked (non-tabs) sections keep their own
-  // Section card and document-flow height since they render a visible title
-  // and aren't confined to a tab panel.
-  const bridges = <ReferenceFacetBridges specs={facetSpecs} onOptions={handleFacetOptions} />;
-
-  if (hideTitle) {
-    return (
-      <>
-        {bridges}
-        {FillContainer !== undefined ? <FillContainer>{content}</FillContainer> : content}
-      </>
-    );
-  }
-
-  return (
-    <>
-      {bridges}
-      <Section
-        title={section.title}
-        {...(actions !== undefined && { actions })}
-        testId={`related-list-${section.title}`}
-      >
-        {content}
-      </Section>
-    </>
-  );
-}

package/src/components/render-edit-action-button.tsx

@@ -1,106 +0,0 @@
-import type { ReactNode } from "react";
-import { useState } from "react";
-import type { usePrimitives } from "../primitives";
-import type { RenderEditAction } from "./render-edit-types";
-
-// Same rule as RowActionWriteHandler: "danger" forces a confirm even
-// without an explicit confirm key — unless `confirmRequired` overrides it
-// (schema-driven navigate/drawer actions, where the target form is itself
-// the confirmation).
-export function needsActionConfirm(action: RenderEditAction): boolean {
-  return action.confirm !== undefined || (action.confirmRequired ?? action.style === "danger");
-}
-
-export function RenderEditActionConfirmDialog({
-  action,
-  open,
-  onOpenChange,
-  onConfirm,
-  Dialog,
-}: {
-  readonly action: RenderEditAction;
-  readonly open: boolean;
-  readonly onOpenChange: (open: boolean) => void;
-  readonly onConfirm: () => void | Promise<void>;
-  readonly Dialog: ReturnType<typeof usePrimitives>["Dialog"];
-}): ReactNode {
-  return (
-    <Dialog
-      open={open}
-      onOpenChange={onOpenChange}
-      title={action.label}
-      {...(action.confirm !== undefined && { description: action.confirm })}
-      confirmLabel={action.confirmLabel ?? action.label}
-      {...(action.style === "danger" && { variant: "danger" as const })}
-      onConfirm={onConfirm}
-      testId={`render-edit-action-${action.id}-dialog`}
-    />
-  );
-}
-
-// One header action + its own busy/confirm state — same pattern as
-// render-list.tsx's ToolbarActionView (each RenderEditAction is
-// independently bound by the caller, there is no shared trigger pipeline
-// to hook into like the built-in onDelete/onSubmit paths have).
-export function RenderEditActionButton({
-  action,
-  iconOnly = false,
-  Button,
-  Dialog,
-  onError,
-}: {
-  readonly action: RenderEditAction;
-  /** Group-level collapse (see `shouldRenderActionsIconOnly`) — only takes
-   *  effect when this action actually resolved an icon. */
-  readonly iconOnly?: boolean;
-  readonly Button: ReturnType<typeof usePrimitives>["Button"];
-  readonly Dialog: ReturnType<typeof usePrimitives>["Dialog"];
-  readonly onError: (text: string | null) => void;
-}): ReactNode {
-  const [busy, setBusy] = useState(false);
-  const [confirmOpen, setConfirmOpen] = useState(false);
-
-  const trigger = async (): Promise<void> => {
-    setBusy(true);
-    onError(null);
-    try {
-      await action.onPress();
-    } catch (e) {
-      onError(e instanceof Error ? e.message : String(e));
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  const variant = action.style ?? "secondary";
-  const showIconOnly = iconOnly && action.icon !== undefined;
-
-  return (
-    <>
-      <Button
-        type="button"
-        variant={variant}
-        loading={busy}
-        {...(action.icon !== undefined && { icon: action.icon })}
-        {...(showIconOnly && { size: "icon" as const, ariaLabel: action.label })}
-        onClick={() => {
-          if (needsActionConfirm(action)) {
-            setConfirmOpen(true);
-          } else {
-            void trigger();
-          }
-        }}
-        testId={`render-edit-action-${action.id}`}
-      >
-        {showIconOnly ? null : action.label}
-      </Button>
-      <RenderEditActionConfirmDialog
-        action={action}
-        open={confirmOpen}
-        onOpenChange={setConfirmOpen}
-        onConfirm={trigger}
-        Dialog={Dialog}
-      />
-    </>
-  );
-}

package/src/components/render-edit-logic.ts

@@ -1,85 +0,0 @@
-import type { EditSectionViewModel, SubmitResult } from "@cosmicdrift/kumiko-headless";
-
-// Hides the Save button when no field is editable and no extension section
-// contributes to the composed form submit. Extensions that persist via their
-// own dispatcher writes must not opt in (fw#2359).
-// Explicit-positive per kind (653/1), not `s.kind !== "fields"` — a future
-// third EditSectionViewModel member would otherwise default to "editable"
-// without anyone deciding that on purpose.
-export function hasEditableSection(sections: readonly EditSectionViewModel[]): boolean {
-  return sections.some(
-    (s) =>
-      (s.kind === "extension" && s.contributesToFormSubmit) ||
-      (s.kind === "fields" && s.visible && s.fields.some((f) => !f.readOnly && f.visible)),
-  );
-}
-
-// Single source of truth for the extension-section entity-id. The section mount
-// and persistExtensions MUST resolve the same id — otherwise a section mounts
-// editable against one id (vm.id) while the persist step writes to (or skips)
-// another (null), silently dropping the user's input. An explicit `null` prop
-// forces "no entity" (no extension persistence); an omitted prop (undefined)
-// falls back to vm.id (= values["id"]), which the update form carries for the
-// existing row, so editing custom fields on that row actually persists.
-export function resolveExtensionEntityId(
-  entityIdProp: string | null | undefined,
-  vmId: string | null,
-): string | null {
-  return entityIdProp !== undefined ? entityIdProp : vmId;
-}
-
-// After a submit, decide whether to invoke the caller's onSubmit. The success
-// callback typically navigates away, which unmounts the extension-error banner.
-// Suppress the callback ONLY when the entity write succeeded but an extension-
-// section persist failed: the user must stay on the form to see the banner and
-// retry. Every other case still notifies the caller — entity failures and
-// validation blocks carry information the caller needs.
-export function shouldNotifyCaller(
-  result: SubmitResult<unknown>,
-  extensionsPersisted: boolean,
-): boolean {
-  return !(result.isSuccess && !extensionsPersisted);
-}
-
-// Matched on the first path segment (embedded-list rows are dotted, e.g. `tasks.2.title`).
-// No issues at all counts as unmatched, so the caller keeps the banner.
-export function hasIssueWithoutRenderedField(
-  issuePaths: readonly string[],
-  sections: readonly EditSectionViewModel[],
-): boolean {
-  if (issuePaths.length === 0) return true;
-  const renderedFields = new Set(
-    sections
-      .filter((s) => s.kind === "fields" && (s.visible || s.fields.length === 0))
-      .flatMap((s) => (s.kind === "fields" ? s.fields.filter((f) => f.visible) : []))
-      .map((f) => f.field),
-  );
-  return issuePaths.some((path) => !renderedFields.has(path.split(".")[0] ?? path));
-}
-
-// Extension, relatedList and writeForm sections skip the `fields` filter
-// (writeForm's fields belong to its own independent form, not the host's);
-// a `fields` section left with zero fields after filtering is dropped, not
-// rendered empty.
-export function filterEditSections(
-  sections: readonly EditSectionViewModel[],
-  fieldsFilter: readonly string[] | undefined,
-): readonly EditSectionViewModel[] {
-  if (fieldsFilter === undefined) return sections;
-  const filterSet = new Set(fieldsFilter);
-  const result: EditSectionViewModel[] = [];
-  for (const section of sections) {
-    if (
-      section.kind === "extension" ||
-      section.kind === "relatedList" ||
-      section.kind === "writeForm"
-    ) {
-      result.push(section);
-      continue;
-    }
-    const fields = section.fields.filter((f) => filterSet.has(f.field));
-    if (fields.length === 0) continue;
-    result.push({ ...section, fields });
-  }
-  return result;
-}