@cosmicdrift/kumiko-renderer 0.387.0 → 0.389.0

package/dist/components/render-list.js

@@ -11,13 +11,15 @@ import { usePageHeaderCompact, usePageHeaderSlotAvailable } from "../page-header
 import { shouldRenderActionsIconOnly, usePrimitives, } from "../primitives.js";
 import { ListEmptyStateBody } from "./list-empty-state.js";
 import { needsActionConfirm } from "./render-edit-action-button.js";
+import { ToolbarActionView } from "./render-list-toolbar-action.js";
 const SEARCH_DEBOUNCE_MS = 300;
-// Icon-less actions are promoted too (with a "plus" fallback at the call site).
+// Icon-less actions are promoted too; on phones the call site falls back to a
+// "plus" icon, on desktop the label carries the action.
 function isHeaderPromotableToolbarAction(action) {
     return action.style === "primary" && !needsActionConfirm(action);
 }
 export function RenderList(props) {
-    const { screen, entity, rows, featureName, translate: translateProp, onRowClick, emptyState, onCreate, createLabel, searchable = false, searchPlaceholder, description, emptyContent, narrowed = false, defaultFilterActive: defaultFilterActiveProp = false, itemNounKey, searchValue, onSearchChange, sort, onSortChange, pager, onReachEnd, loadingMore, hasMore, rowActions, rowActionMode, rowGrouping, rowTone, toolbarActions, filterFacets, filterValues, onFilterChange, onFilterReset, dateRangeFacets, onDateRangeChange, chromeless, scrollBody, screenPadding, expandedRowIds, onToggleRowExpanded, renderExpandedRow, } = props;
+    const { screen, entity, rows, featureName, translate: translateProp, onRowClick, emptyState, onCreate, createLabel, searchable = false, searchPlaceholder, description, emptyContent, narrowed = false, defaultFilterActive: defaultFilterActiveProp = false, itemNounKey, searchValue, onSearchChange, sort, onSortChange, pager, onReachEnd, loadingMore, hasMore, rowActions, rowActionMode, bulk, rowTone, toolbarActions, filterFacets, filterValues, onFilterChange, onFilterReset, dateRangeFacets, onDateRangeChange, chromeless, scrollBody, screenPadding, expandedRowIds, onToggleRowExpanded, renderExpandedRow, ...tableBlockProps } = props;
     // As in RenderEdit, fall back to the i18next context for translation;
     // otherwise column headers would display raw i18n keys.
     const t = useTranslation();
@@ -26,6 +28,10 @@ export function RenderList(props) {
     const pageHeaderSlotAvailable = usePageHeaderSlotAvailable();
     const pageHeaderCompact = usePageHeaderCompact();
     const createInPageHeader = onCreate !== undefined && PageHeader !== undefined && pageHeaderSlotAvailable;
+    // Promoted actions that moved into the phone header's overflow menu have no button of
+    // their own, so their busy and error state lives here.
+    const [menuActionBusyId, setMenuActionBusyId] = useState(null);
+    const [menuActionError, setMenuActionError] = useState(null);
     // Local search buffer + debounce. External changes (browser back,
     // cross-component reset) are mirrored back; typing only fires
     // onSearchChange after 300ms without further keystrokes.
@@ -37,24 +43,31 @@ export function RenderList(props) {
     // The parent may echo our own debounced emits back late (router/URL round
     // trip), possibly after a newer emit already went out; adopting such a stale
     // echo would erase keys typed in between. All unechoed emits are kept, and a
-    // matching echo drops itself and every older one.
+    // matching echo drops itself and every older one. The render phase only reads
+    // the list (a discarded or repeated render must find the echo again); the
+    // matched entries are dropped in an effect.
     const pendingEmitsRef = useRef([]);
     if (searchValue !== syncedSearchValue) {
         setSyncedSearchValue(searchValue);
-        const echoIndex = pendingEmitsRef.current.indexOf(searchValue ?? "");
-        if (echoIndex >= 0) {
-            pendingEmitsRef.current.splice(0, echoIndex + 1);
-        }
-        else {
+        if (!pendingEmitsRef.current.includes(searchValue ?? "")) {
             setLocalQ(searchValue ?? "");
             pendingEmitsRef.current = [];
         }
     }
+    useEffect(() => {
+        const echoIndex = pendingEmitsRef.current.indexOf(syncedSearchValue ?? "");
+        if (echoIndex >= 0)
+            pendingEmitsRef.current.splice(0, echoIndex + 1);
+    }, [syncedSearchValue]);
     useEffect(() => {
         if (onSearchChange === undefined)
             return;
         if (localQ === (searchValue ?? ""))
             return;
+        // A late echo of an older emit changes searchValue but must not re-send
+        // the value that is already in flight.
+        if (pendingEmitsRef.current.at(-1) === localQ)
+            return;
         const timer = setTimeout(() => {
             pendingEmitsRef.current.push(localQ);
             onSearchChange(localQ);
@@ -79,14 +92,15 @@ export function RenderList(props) {
         labelField: c.refLabelField ?? "id",
     })), [vm.columns, featureName]);
     const [referenceLookups, setReferenceLookups] = useState({});
-    const handleLookupMap = useCallback((field, map) => {
+    const handleLookupMap = useCallback((field, lookup) => {
         setReferenceLookups((prev) => {
-            // Skip the update when the map is identical. Otherwise the bridge
+            // Skip the update when the lookup is identical. Otherwise the bridge
             // would re-render and send the same map back until React entered
             // an infinite loop.
-            if (prev[field] === map)
+            const current = prev[field];
+            if (current?.map === lookup.map && current.complete === lookup.complete)
                 return prev;
-            return { ...prev, [field]: map };
+            return { ...prev, [field]: lookup };
         });
     }, []);
     const resolveReferenceLink = useReferenceLinkResolver();
@@ -100,15 +114,19 @@ export function RenderList(props) {
             // the default is used only when none is set.
             if (col.renderer !== undefined)
                 return col;
-            const map = referenceLookups[col.field];
+            const published = referenceLookups[col.field];
+            const map = published?.map;
             const unknownKey = UNRESOLVED_REFERENCE_LABEL_KEYS[`${col.refFeature ?? featureName}:${col.refEntity ?? ""}`];
             // No raw id for entities that opt in: a placeholder while the lookup
-            // loads, the "unknown" label once it found nothing.
+            // loads, the "unknown" label once the complete lookup found nothing. A
+            // capped lookup page cannot prove absence, so it keeps the raw id.
             const unresolvedLabel = (id) => unknownKey === undefined
                 ? id
-                : map === undefined
+                : published === undefined
                     ? EMPTY_VALUE_PLACEHOLDER
-                    : translate(unknownKey);
+                    : published.complete
+                        ? translate(unknownKey)
+                        : id;
             const labelField = col.refLabelField ?? "id";
             const refEntity = col.refEntity ?? "";
             // Only a row the user can see is linkable: resolved by the server
@@ -201,16 +219,41 @@ export function RenderList(props) {
     const hasHeaderSlot = screen.slots?.header !== undefined;
     const toolbarIconOnly = hasToolbarActions && shouldRenderActionsIconOnly(toolbarActions);
     const createButton = onCreate !== undefined && createInPageHeader && pageHeaderCompact ? (_jsx(Button, { variant: "primary", icon: "plus", size: "icon", ariaLabel: effectiveCreateLabel, title: effectiveCreateLabel, onClick: onCreate, testId: "render-list-create" })) : onCreate !== undefined ? (_jsx(Button, { variant: "primary", icon: "plus", onClick: onCreate, testId: "render-list-create", className: "px-3.5", children: effectiveCreateLabel })) : undefined;
-    // Without onCreate (e.g. a navigate action as the list's only CTA) the primary
-    // toolbar action takes the page-header slot like a "+ Neu" button would: an icon
-    // on phones, labelled on desktop, so projection lists look like entity lists.
-    const promotedToolbarAction = onCreate === undefined && PageHeader !== undefined && pageHeaderSlotAvailable
-        ? toolbarActions?.find(isHeaderPromotableToolbarAction)
-        : undefined;
-    const promotedActionButton = promotedToolbarAction !== undefined ? (_jsx(ToolbarActionView, { action: pageHeaderCompact
-            ? { ...promotedToolbarAction, icon: promotedToolbarAction.icon ?? "plus" }
-            : promotedToolbarAction, iconOnly: pageHeaderCompact, Button: Button, Dialog: Dialog, Banner: Banner })) : undefined;
-    const toolbarActionsInToolbar = toolbarActions?.filter((a) => a !== promotedToolbarAction) ?? [];
+    // Every primary toolbar action takes the page-header slot, left of the create
+    // button (which stays the rightmost primary action): labelled on desktop, so
+    // projection lists look like entity lists. On phones an icon button, or, next to
+    // the create button, an entry in the header's overflow menu: the header has no
+    // room for a labelled action beside it.
+    const promotedToolbarActions = PageHeader !== undefined && pageHeaderSlotAvailable
+        ? (toolbarActions?.filter(isHeaderPromotableToolbarAction) ?? [])
+        : [];
+    const promotedInOverflowMenu = pageHeaderCompact && createInPageHeader && promotedToolbarActions.length > 0;
+    const promotedMenuItems = promotedInOverflowMenu
+        ? promotedToolbarActions.map((a) => ({
+            id: a.id,
+            label: a.label,
+            ...(a.icon !== undefined && { icon: a.icon }),
+            ...(menuActionBusyId !== null && { disabled: true }),
+            testId: `render-list-toolbar-action-${a.id}`,
+            onSelect: () => {
+                setMenuActionBusyId(a.id);
+                setMenuActionError(null);
+                void (async () => {
+                    try {
+                        await a.onTrigger();
+                    }
+                    catch (e) {
+                        setMenuActionError(e instanceof Error ? e.message : String(e));
+                    }
+                    finally {
+                        setMenuActionBusyId(null);
+                    }
+                })();
+            },
+        }))
+        : [];
+    const headerActions = promotedToolbarActions.length > 0 && !promotedInOverflowMenu ? (_jsxs(_Fragment, { children: [promotedToolbarActions.map((a) => (_jsx(ToolbarActionView, { action: pageHeaderCompact ? { ...a, icon: a.icon ?? "plus" } : a, iconOnly: pageHeaderCompact, Button: Button, Dialog: Dialog, Banner: Banner }, a.id))), createInPageHeader && createButton] })) : createInPageHeader ? (createButton) : undefined;
+    const toolbarActionsInToolbar = toolbarActions?.filter((a) => !promotedToolbarActions.includes(a)) ?? [];
     const hasToolbarActionsInToolbar = toolbarActionsInToolbar.length > 0;
     const toolbarEnd = hasHeaderSlot ||
         hasToolbarActionsInToolbar ||
@@ -229,8 +272,7 @@ export function RenderList(props) {
     const titleKey = `screen:${screen.id}.title`;
     const resolvedTitle = translate(titleKey);
     const toolbarTitle = resolvedTitle === titleKey ? screen.id : resolvedTitle;
-    // ListSort = DataTableSort (aliased in use-list-url-state), so no cast is needed.
-    return (_jsxs(_Fragment, { children: [createInPageHeader && PageHeader !== undefined && _jsx(PageHeader, { actions: createButton }), promotedActionButton !== undefined && PageHeader !== undefined && (_jsx(PageHeader, { actions: promotedActionButton })), referenceColumns.map((rc) => (_jsx(ReferenceLookupBridge, { field: rc.field, refEntity: rc.refEntity, labelField: rc.labelField, featureName: rc.refFeature, onMap: handleLookupMap }, rc.field))), _jsx(DataTable, { columns: enrichedVm.columns, rows: enrichedVm.rows, toolbarTitle: toolbarTitle, ...(onRowClick !== undefined && { onRowClick }), ...(composedEmptyState !== undefined && { emptyState: composedEmptyState }), ...(toolbarStart !== undefined && { toolbarStart }), ...(description !== undefined && { toolbarDescription: description }), ...(toolbarEnd !== undefined && { toolbarEnd }), ...(sort !== undefined && { sort }), ...(onSortChange !== undefined && { onSortChange }), ...(pager !== undefined && { pager }), ...(onReachEnd !== undefined && { onReachEnd }), ...(loadingMore !== undefined && { loadingMore }), ...(hasMore !== undefined && { hasMore }), ...(itemNoun !== undefined && { itemNoun }), ...(rowActions !== undefined && { rowActions }), ...(rowActionMode !== undefined && { rowActionMode }), ...(rowGrouping !== undefined && { rowGrouping }), ...(rowTone !== undefined && { rowTone }), ...(filterFacets !== undefined && { filterFacets }), ...(filterValues !== undefined && { filterValues }), ...(onFilterChange !== undefined && { onFilterChange }), ...(onFilterReset !== undefined && { onFilterReset }), ...(dateRangeFacets !== undefined && { dateRangeFacets }), ...(onDateRangeChange !== undefined && { onDateRangeChange }), ...(chromeless !== undefined && { chromeless }), ...(scrollBody !== undefined && { scrollBody }), ...(screenPadding !== undefined && { screenPadding }), ...(expandedRowIds !== undefined && { expandedRowIds }), ...(onToggleRowExpanded !== undefined && { onToggleRowExpanded }), ...(renderExpandedRow !== undefined && { renderExpandedRow }), testId: "render-list-table" })] }));
+    return (_jsxs(_Fragment, { children: [headerActions !== undefined && PageHeader !== undefined && (_jsx(PageHeader, { actions: headerActions, ...(promotedInOverflowMenu && { overflowItems: promotedMenuItems }) })), menuActionError !== null && (_jsx(Banner, { variant: "error", testId: "render-list-toolbar-action-error", children: menuActionError })), referenceColumns.map((rc) => (_jsx(ReferenceLookupBridge, { field: rc.field, refEntity: rc.refEntity, labelField: rc.labelField, featureName: rc.refFeature, onMap: handleLookupMap }, rc.field))), _jsx(DataTable, { columns: enrichedVm.columns, rows: enrichedVm.rows, toolbarTitle: toolbarTitle, ...(onRowClick !== undefined && { onRowClick }), ...(composedEmptyState !== undefined && { emptyState: composedEmptyState }), ...(toolbarStart !== undefined && { toolbarStart }), ...(description !== undefined && { toolbarDescription: description }), ...(toolbarEnd !== undefined && { toolbarEnd }), ...(sort !== undefined && { sort }), ...(onSortChange !== undefined && { onSortChange }), ...(pager !== undefined && { pager }), ...(onReachEnd !== undefined && { onReachEnd }), ...(loadingMore !== undefined && { loadingMore }), ...(hasMore !== undefined && { hasMore }), ...(itemNoun !== undefined && { itemNoun }), ...(rowActions !== undefined && { rowActions }), ...(rowActionMode !== undefined && { rowActionMode }), ...(bulk !== undefined && { bulk }), ...(rowTone !== undefined && { rowTone }), ...(filterFacets !== undefined && { filterFacets }), ...(filterValues !== undefined && { filterValues }), ...(onFilterChange !== undefined && { onFilterChange }), ...(onFilterReset !== undefined && { onFilterReset }), ...(dateRangeFacets !== undefined && { dateRangeFacets }), ...(onDateRangeChange !== undefined && { onDateRangeChange }), ...(chromeless !== undefined && { chromeless }), ...(scrollBody !== undefined && { scrollBody }), ...(screenPadding !== undefined && { screenPadding }), ...(expandedRowIds !== undefined && { expandedRowIds }), ...(onToggleRowExpanded !== undefined && { onToggleRowExpanded }), ...(renderExpandedRow !== undefined && { renderExpandedRow }), ...tableBlockProps, testId: "render-list-table" })] }));
 }
 // Header slot in the list toolbar (toolbarEnd): `screen.slots.header` is
 // a PlatformComponent (`{ react: { __component: "X" } }`) resolved through
@@ -273,47 +315,10 @@ function ReferenceLookupBridge({ field, refEntity, labelField, featureName, onMa
     const resolved = !lookup.loading && !lookup.failed;
     useEffect(() => {
         if (resolved)
-            onMap(field, lookup.map);
-    }, [field, lookup.map, resolved, onMap]);
+            onMap(field, { map: lookup.map, complete: lookup.complete });
+    }, [field, lookup.map, lookup.complete, resolved, onMap]);
     return null;
 }
-// ToolbarActionView renders one button per toolbar action, with a confirm
-// dialog when required. It follows the inline RowAction pattern but has no
-// row context. The busy state covers async onTrigger; the dialog opens before
-// the trigger when confirmation is required for confirm/danger actions.
-function ToolbarActionView({ action, iconOnly = false, Button, Dialog, Banner, }) {
-    const [busy, setBusy] = useState(false);
-    const [confirmOpen, setConfirmOpen] = useState(false);
-    // Toolbar actions do not have access to the toast primitive, unlike
-    // rowActions routed through the DataTable primitive, so an inline error
-    // banner is used to surface failures. Without it, a swallowed failure result
-    // would look to the user as though nothing happened.
-    const [errorText, setErrorText] = useState(null);
-    const trigger = async () => {
-        setBusy(true);
-        setErrorText(null);
-        try {
-            await action.onTrigger();
-        }
-        catch (e) {
-            setErrorText(e instanceof Error ? e.message : String(e));
-        }
-        finally {
-            setBusy(false);
-        }
-    };
-    const variant = action.style ?? "secondary";
-    const needsConfirm = needsActionConfirm(action);
-    const showIconOnly = iconOnly && action.icon !== undefined;
-    return (_jsxs(_Fragment, { children: [_jsx(Button, { variant: variant, loading: busy, ...(action.icon !== undefined && { icon: action.icon }), size: showIconOnly ? "icon" : "sm", ...(showIconOnly && { ariaLabel: action.label, title: action.label }), onClick: () => {
-                    if (needsConfirm) {
-                        setConfirmOpen(true);
-                    }
-                    else {
-                        void trigger();
-                    }
-                }, testId: `render-list-toolbar-action-${action.id}`, children: showIconOnly ? null : action.label }), _jsx(Dialog, { open: confirmOpen, onOpenChange: setConfirmOpen, title: action.label, ...(action.confirm !== undefined && { description: action.confirm }), confirmLabel: action.confirmLabel ?? action.label, ...(action.style === "danger" && { variant: "danger" }), onConfirm: trigger, testId: `render-list-toolbar-action-${action.id}-dialog` }), errorText !== null && (_jsx(Banner, { variant: "error", testId: `render-list-toolbar-action-${action.id}-error`, children: errorText }))] }));
-}
 function isPlainRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/current-user.d.ts

@@ -7,6 +7,8 @@ export type CurrentUser = {
     readonly displayName: string;
     /** Effective IANA zone of the user (override, else tenant). */
     readonly timeZone?: string;
+    /** Active tenant; scopes per-user browser state such as remembered list views. */
+    readonly tenantId?: string;
 };
 export declare function CurrentUserProvider({ user, children, }: {
     readonly user: CurrentUser | undefined;

package/dist/data-table-aggregate-types.d.ts

@@ -0,0 +1,47 @@
+import type { AggregateKey } from "@cosmicdrift/kumiko-types/aggregate-types";
+import type { ListAggregateMeasureKind, ListAggregateValue } from "@cosmicdrift/kumiko-types/list-aggregate-types";
+/** One server-computed measure; a money measure holds one minor-unit value per currency. */
+export type DataTableMeasure = {
+    readonly field: string;
+    readonly kind: ListAggregateMeasureKind;
+    readonly value: ListAggregateValue;
+};
+export type DataTableServerGroup = {
+    /** `relatedListGroupKey` of the group value; stable across reloads. */
+    readonly key: string;
+    /** Raw group value, rendered through the group column when `label` is absent. */
+    readonly value: AggregateKey;
+    readonly label?: string;
+    /** Rows of the whole group on the server, not the loaded ones. */
+    readonly count: number;
+    readonly measures: readonly DataTableMeasure[];
+    readonly collapsed: boolean;
+    /** How many of the table's `rows` belong to this group; rows arrive in group order. */
+    readonly rowCount: number;
+    readonly hasMore: boolean;
+    readonly loading: boolean;
+};
+/** Server-side grouping: groups are the load unit, each loads its own rows. */
+export type DataTableServerGroups = {
+    readonly field: string;
+    readonly groups: readonly DataTableServerGroup[];
+    readonly totalCount: number;
+    readonly onToggle: (key: string) => void;
+    readonly onLoadMore: (key: string) => void;
+    readonly onHeaderVisible: (key: string) => void;
+};
+export type DataTableTotals = {
+    readonly measures: readonly DataTableMeasure[];
+};
+/** `truncated`: more groups than the server answers. `searchTruncated`: the search hit its cap. */
+export type DataTableListNotice = "truncated" | "searchTruncated";
+export type DataTableRangeBound = "min" | "max";
+/** "From/to" inputs on a number field. Values are the typed strings, "" = open bound. */
+export type DataTableRangeFacet = {
+    readonly field: string;
+    readonly label: string;
+    readonly min: string;
+    readonly max: string;
+    /** Shown after the inputs, e.g. the money field's currency. */
+    readonly unit?: string;
+};

package/dist/data-table-aggregate-types.js

@@ -0,0 +1 @@
+export {};

package/dist/data-table-bulk-types.d.ts

@@ -0,0 +1,27 @@
+import type { IconKey } from "@cosmicdrift/kumiko-types/nav-icon";
+import type { ListRowViewModel } from "./headless/index.ts";
+export type BulkRowOutcome = {
+    readonly kind: "succeeded";
+} | {
+    readonly kind: "failed";
+    readonly message: string;
+};
+export type DataTableBulkAction = {
+    readonly id: string;
+    /** Translated label of the underlying row action. */
+    readonly label: string;
+    readonly style?: "primary" | "secondary" | "danger";
+    readonly icon?: IconKey;
+    /** Present: one confirm dialog for the whole selection, with this text for `count` rows. */
+    readonly confirmText?: (count: number) => string;
+    readonly confirmLabel?: string;
+    /** False: the row action's `visible` hides it for this row; the run skips the row. */
+    readonly appliesTo: (row: ListRowViewModel) => boolean;
+    /** Exactly one server write for one row. Never throws for a rejected write. */
+    readonly writeRow: (row: ListRowViewModel) => Promise<BulkRowOutcome>;
+};
+export type DataTableBulk = {
+    readonly actions: readonly DataTableBulkAction[];
+    /** Reloads the list once after a run. */
+    readonly reload: () => Promise<void>;
+};

package/dist/data-table-bulk-types.js

@@ -0,0 +1 @@
+export {};

package/dist/data-table-facet-types.d.ts

@@ -0,0 +1,36 @@
+export type DataTableFacet = {
+    /** Entity-Feldname (= URL-State-Key + payload.filters[].field). */
+    readonly field: string;
+    /** Translated Button-Label ("Status", "Active"). */
+    readonly label: string;
+    /** Selectable values with display labels. `value` is the raw filter value
+     *  (a select option or `"true"`/`"false"`), transported as a string. */
+    readonly options: readonly {
+        readonly value: string;
+        readonly label: string;
+    }[];
+    /** Present: render the facet as a row of single-choice toggle chips instead
+     *  of a dropdown. A chip is pressed while the selection equals its values. */
+    readonly chips?: readonly DataTableFacetChip[];
+    /** Chips only: show each chip's `count` next to its label. */
+    readonly showCounts?: boolean;
+    /** Chips only: hide chips whose `count` is 0 (unless pressed). */
+    readonly hideEmpty?: boolean;
+};
+export type DataTableFacetChip = {
+    readonly id: string;
+    /** Translated chip label. */
+    readonly label: string;
+    /** Selection a click sets; `[]` clears the facet. */
+    readonly values: readonly string[];
+    /** Matching row count, undefined while unknown. */
+    readonly count?: number;
+};
+export type DataTableDateRangeFacet = {
+    /** The facet's namespace (its date field) — a key, not a filter value. */
+    readonly field: string;
+    /** Translated label ("When"). */
+    readonly label: string;
+    readonly from: string;
+    readonly to: string;
+};

package/dist/data-table-facet-types.js

@@ -0,0 +1 @@
+export {};

package/dist/data-table-view-types.d.ts

@@ -0,0 +1,73 @@
+import type { ListColumnPin, ListTableDensity } from "@cosmicdrift/kumiko-types/screen";
+import type { DataTableListNotice, DataTableRangeBound, DataTableRangeFacet, DataTableServerGroups, DataTableTotals } from "./data-table-aggregate-types.ts";
+export type DataTableDensity = ListTableDensity;
+export type DataTableColumnPin = ListColumnPin;
+export type DataTableColumnPins = Readonly<Record<string, DataTableColumnPin>>;
+export type DataTableColumnWidths = Readonly<Record<string, number>>;
+/** One column in the view menu. The label comes from the DataTable's own
+ *  column of the same `field`. */
+export type DataTableViewColumn = {
+    readonly field: string;
+    readonly visible: boolean;
+};
+export type DataTableViewOptions = {
+    /** Present: the view menu has a column section (visibility + order). The
+     *  order lists every column; hidden ones stay in the list. */
+    readonly columns?: readonly DataTableViewColumn[];
+    readonly onColumnsChange?: (next: readonly DataTableViewColumn[]) => void;
+    readonly density: DataTableDensity;
+    /** Present: the view menu has a density section. */
+    readonly onDensityChange?: (next: DataTableDensity) => void;
+    /** Present: pinning is on and the view menu has a pin section. Unpinned columns have no entry. */
+    readonly pins?: DataTableColumnPins;
+    readonly onPinsChange?: (next: DataTableColumnPins) => void;
+    /** Present: resizing is on; the table switches to table-layout fixed. Every column has an entry (px). */
+    readonly widths?: DataTableColumnWidths;
+    /** Present together with `widths`; every column has an entry (px). */
+    readonly minWidths?: DataTableColumnWidths;
+    readonly onWidthChange?: (field: string, width: number) => void;
+    readonly keyboardNavigation?: boolean;
+    /** Present: the view menu has a "group by" section. */
+    readonly groupBy?: DataTableGroupByChoice;
+    /** False once columns, order or density differ from the screen default. */
+    readonly viewIsDefault: boolean;
+    readonly onViewReset: () => void;
+};
+export type DataTableGroupByChoice = {
+    /** Active group field, "" = not grouped. */
+    readonly value: string;
+    readonly fields: readonly string[];
+    readonly onChange: (next: string) => void;
+};
+export type DataTableResetAll = {
+    /** True while something deviates from the screen default. */
+    readonly active: boolean;
+    readonly onReset: () => void;
+};
+/** What the export button sends to POST /api/export/xlsx (xlsx is the only format). */
+export type DataTableExport = {
+    /** Screen QN `<feature>:screen:<id>`. */
+    readonly screen: string;
+    readonly screenShortId: string;
+    /** The list payload without paging keys; the server reads the whole filtered list. */
+    readonly payload: Readonly<Record<string, unknown>>;
+    /** Visible column ids in display order. */
+    readonly columns: readonly string[];
+};
+/** The DataTable props a screen's `table` block feeds. */
+export type DataTableTableBlock = {
+    /** View menu (column picker, density); absent = no menu. */
+    readonly view?: DataTableViewOptions;
+    /** Replaces the facet reset with one that also covers sort, search and page size. */
+    readonly resetAll?: DataTableResetAll;
+    /** Present: the toolbar has an export button (web only). */
+    readonly exportList?: DataTableExport;
+    /** Present: the rows are grouped on the server; replaces pager and infinite scroll. */
+    readonly serverGroups?: DataTableServerGroups;
+    /** Present: a footer row with the server-computed totals of the filtered list. */
+    readonly totals?: DataTableTotals;
+    /** Present: the toolbar says the answer is incomplete and asks to narrow the list. */
+    readonly notice?: DataTableListNotice;
+    readonly rangeFacets?: readonly DataTableRangeFacet[];
+    readonly onRangeChange?: (field: string, bound: DataTableRangeBound, value: string) => void;
+};

package/dist/data-table-view-types.js

@@ -0,0 +1 @@
+export {};

package/dist/flow-diagram/render.js

@@ -23,7 +23,15 @@ function cardSize(node) {
     return { width, height };
 }
 function assertEdgesReferenceKnownNodes(spec) {
-    const ids = new Set(spec.nodes.map((n) => n.id));
+    const ids = new Set();
+    for (const node of spec.nodes) {
+        if (ids.has(node.id))
+            throw new Error(`FlowSpec: duplicate node id "${node.id}"`);
+        ids.add(node.id);
+        if (node.icon !== undefined && node.icon !== "ai" && !Object.hasOwn(ICONS, node.icon)) {
+            throw new Error(`FlowSpec: node "${node.id}" has unknown icon "${node.icon}"`);
+        }
+    }
     for (const edge of spec.edges) {
         if (!ids.has(edge.from))
             throw new Error(`FlowSpec: edge references unknown node "${edge.from}"`);

package/dist/headless/form/form-controller.js

@@ -217,6 +217,13 @@ export function createFormController(options) {
             errors = Object.freeze({});
         invalidate();
     }
+    function runRebaseFields(fields) {
+        initial = {
+            ...initial,
+            ...Object.fromEntries(fields.map((field) => [field, values[field]])),
+        };
+        invalidate();
+    }
     // Stale-submit-safe rebase. Difference to runRebase: the baseline is
     // taken from the values that were actually SENT to the server, not
     // from `values` at the moment the server replied. If the user typed
@@ -296,6 +303,7 @@ export function createFormController(options) {
             invalidate();
         },
         rebase: runRebase,
+        rebaseFields: runRebaseFields,
         setCtx(nextCtx) {
             // Cast back to TCtx: setCtx's public signature takes unknown so
             // callers don't need to plumb generics. If conditions depend on ctx

package/dist/headless/form/types.d.ts

@@ -33,6 +33,7 @@ export type FormController<TValues extends FormValues> = {
     validate(scope?: readonly FormScopeKey<TValues>[]): boolean;
     reset(): void;
     rebase(): void;
+    rebaseFields(fields: readonly string[]): void;
     setCtx(ctx: unknown): void;
     submit<TData = unknown>(): Promise<SubmitResult<TData>>;
 };