@declarion/react 0.6.6 → 0.6.7

package/dist-lib/DraggableChildrenTable-CdzxxoTe.js

@@ -0,0 +1,259 @@
+import { Qt as e, St as t, Xt as n, Zt as r, a as i, i as a, n as o, r as s, t as c, ut as l } from "./dataTableStyles-zH3M7xdm.js";
+import { useCallback as u, useMemo as d, useRef as f } from "react";
+import { jsx as p, jsxs as m } from "react/jsx-runtime";
+import { DndContext as h, PointerSensor as g, closestCenter as _, useSensor as v, useSensors as y } from "@dnd-kit/core";
+import { SortableContext as b, useSortable as x, verticalListSortingStrategy as S } from "@dnd-kit/sortable";
+import { CSS as C } from "@dnd-kit/utilities";
+//#region src/components/detail-layout/DraggableChildrenTable.tsx
+function w({ config: t, childEntity: n, schema: i, rows: a, onChange: c, validationErrors: x, refs: C }) {
+	let w = f(null), E = t.position_field, D = t.columns, O = y(v(g, { activationConstraint: { distance: 5 } })), k = new Set(Array.isArray(t.foreign_key) ? t.foreign_key : [t.foreign_key]), A = D.filter((e) => {
+		if (k.has(e) || e === E) return !1;
+		let t = n.fields.get(e);
+		return !(!t || t.auto || t.primary);
+	}), j = new Set(D.filter((e) => {
+		if (e === E) return !0;
+		let t = n.fields.get(e);
+		return t && (t.auto || t.primary);
+	})), M = D.filter((e) => e !== E), N = d(() => a.filter((e) => !e._deleted).map((e) => e._key), [a]), P = u((e, t, n) => {
+		c(a.map((r) => r._key === e ? {
+			...r,
+			[t]: n,
+			_dirty: !0
+		} : r));
+	}, [a, c]), F = u(() => {
+		let e = a.filter((e) => !e._deleted).reduce((e, t) => {
+			let n = typeof t[E] == "number" ? t[E] : -1;
+			return Math.max(e, n);
+		}, -1), r = {
+			_key: crypto.randomUUID(),
+			_dirty: !0,
+			[E]: e + 1
+		}, i = t.quick_add?.defaults ?? {};
+		for (let e of A) {
+			let t = n.fields.get(e);
+			t && (i[e] === void 0 ? t.default === void 0 ? t.type === "bool" && (r[e] = !1) : r[e] = t.default : r[e] = i[e]);
+		}
+		c([...a, r]);
+	}, [
+		a,
+		c,
+		A,
+		n,
+		t.quick_add?.defaults,
+		E
+	]), I = u((e) => {
+		c(a.map((t) => t._key === e ? {
+			...t,
+			_deleted: !0
+		} : t));
+	}, [a, c]), L = u((e) => {
+		c(a.map((t) => t._key === e ? {
+			...t,
+			_deleted: !1
+		} : t));
+	}, [a, c]), R = u((e) => {
+		let { active: t, over: n } = e;
+		if (!n || t.id === n.id) return;
+		let r = a.filter((e) => !e._deleted), i = a.filter((e) => e._deleted), o = r.findIndex((e) => e._key === String(t.id)), s = r.findIndex((e) => e._key === String(n.id));
+		if (o === -1 || s === -1) return;
+		let l = [...r], [u] = l.splice(o, 1);
+		l.splice(s, 0, u), c([...l.map((e, t) => ({
+			...e,
+			[E]: t,
+			_dirty: e[E] === t ? e._dirty : !0
+		})), ...i]);
+	}, [
+		a,
+		c,
+		E
+	]), z = u((e) => {
+		let t = e.target, n = t.closest("td");
+		if (!n) return;
+		let r = n.closest("tr");
+		if (!r) return;
+		let i = r.closest("tbody");
+		if (!i) return;
+		let a = Array.from(r.cells).indexOf(n), o = Array.from(i.rows).indexOf(r);
+		if (e.key === "Tab") {
+			let t = e.shiftKey ? -1 : 1, n = Array.from(i.rows), r = o, s = a + t;
+			for (; r >= 0 && r < n.length;) if (s >= 0 && s < n[r].cells.length) {
+				let i = n[r].cells[s].querySelector("input, select, textarea, [tabindex]");
+				if (i) {
+					e.preventDefault(), i.focus();
+					return;
+				}
+				s += t;
+			} else r += t, s = t > 0 ? 0 : (n[r]?.cells.length ?? 1) - 1;
+		} else if (e.key === "Enter") {
+			e.preventDefault();
+			let t = Array.from(i.rows);
+			if (o < t.length - 1) {
+				let e = t[o + 1].cells[a]?.querySelector("input, select, textarea, [tabindex]");
+				e && e.focus();
+			} else F(), requestAnimationFrame(() => {
+				let e = i.querySelectorAll("tr"), t = e[e.length - 1];
+				if (t) {
+					let e = t.querySelector("input, select, textarea, [tabindex]");
+					e && e.focus();
+				}
+			});
+		} else e.key === "Escape" && t.blur?.();
+	}, [F]), B = o;
+	return /* @__PURE__ */ m("div", { children: [/* @__PURE__ */ p("div", {
+		style: { overflowX: "auto" },
+		children: /* @__PURE__ */ p(h, {
+			sensors: O,
+			collisionDetection: _,
+			onDragEnd: R,
+			children: /* @__PURE__ */ m("table", {
+				ref: w,
+				style: s,
+				onKeyDown: z,
+				children: [/* @__PURE__ */ p("thead", { children: /* @__PURE__ */ m("tr", { children: [
+					/* @__PURE__ */ p("th", { style: {
+						...B,
+						width: 32,
+						padding: "0 4px"
+					} }),
+					M.map((e) => {
+						let t = n.fields.get(e);
+						return /* @__PURE__ */ p("th", {
+							style: B,
+							children: t ? l(t, e, i.entities) : e
+						}, e);
+					}),
+					/* @__PURE__ */ p("th", { style: {
+						...B,
+						width: 40
+					} })
+				] }) }), /* @__PURE__ */ p(b, {
+					items: N,
+					strategy: S,
+					children: /* @__PURE__ */ p("tbody", { children: a.map((e) => /* @__PURE__ */ p(T, {
+						row: e,
+						columns: M,
+						editableColumns: A,
+						displayOnlyColumns: j,
+						childEntity: n,
+						validationErrors: x,
+						refs: C,
+						onCellChange: P,
+						onDelete: I,
+						onUndoDelete: L
+					}, e._key)) })
+				})]
+			})
+		})
+	}), /* @__PURE__ */ p("div", {
+		style: { marginTop: 8 },
+		children: /* @__PURE__ */ p(r, {
+			kind: "ghost",
+			size: "xs",
+			icon: /* @__PURE__ */ p(e.plus, { size: 12 }),
+			onClick: F,
+			children: "Add row"
+		})
+	})] });
+}
+function T({ row: r, columns: o, editableColumns: s, displayOnlyColumns: l, childEntity: u, validationErrors: d, refs: f, onCellChange: h, onDelete: g, onUndoDelete: _ }) {
+	let v = a(), y = !!r._deleted, b = d?.[r._key], { attributes: S, listeners: w, setNodeRef: T, transform: E, transition: D, isDragging: O } = x({
+		id: r._key,
+		disabled: y
+	}), k = {
+		transform: C.Translate.toString(E),
+		transition: D,
+		zIndex: O ? 10 : void 0,
+		opacity: O ? .5 : void 0
+	}, A = c, j = {
+		padding: "4px 4px",
+		borderBottom: "1px solid var(--divider)",
+		verticalAlign: "middle"
+	};
+	return /* @__PURE__ */ m("tr", {
+		ref: T,
+		style: {
+			...k,
+			opacity: y ? .5 : k?.opacity ?? 1
+		},
+		children: [
+			/* @__PURE__ */ p("td", {
+				style: {
+					padding: "4px 4px",
+					borderBottom: "1px solid var(--divider)",
+					width: 32,
+					verticalAlign: "middle"
+				},
+				children: !y && /* @__PURE__ */ p("button", {
+					type: "button",
+					style: {
+						cursor: "grab",
+						padding: 4,
+						color: "var(--text-3)",
+						background: "transparent",
+						border: 0,
+						display: "inline-flex"
+					},
+					...S,
+					...w,
+					children: /* @__PURE__ */ p(e.grid, { size: 14 })
+				})
+			}),
+			o.map((e) => {
+				let n = u.fields.get(e), a = b?.includes(e), o = l.has(e), c = s.includes(e);
+				return y || o || !c ? /* @__PURE__ */ p("td", {
+					style: {
+						...A,
+						textDecoration: y ? "line-through" : "none"
+					},
+					children: n ? i({
+						field: n,
+						fieldName: e,
+						value: r[e],
+						mode: "display",
+						record: r,
+						refs: f,
+						locale: v
+					}) : t(r[e])
+				}, e) : /* @__PURE__ */ p("td", {
+					style: {
+						...j,
+						outline: a ? "1px solid var(--danger)" : "none",
+						outlineOffset: -1,
+						borderRadius: a ? 4 : 0
+					},
+					title: a ? `${e} is required` : void 0,
+					children: n ? i({
+						field: n,
+						fieldName: e,
+						value: r[e],
+						mode: "edit",
+						onChange: (t) => h(r._key, e, t),
+						record: r,
+						refs: f,
+						locale: v
+					}) : t(r[e])
+				}, e);
+			}),
+			/* @__PURE__ */ p("td", {
+				style: {
+					padding: "4px 8px",
+					borderBottom: "1px solid var(--divider)",
+					verticalAlign: "middle"
+				},
+				children: y ? /* @__PURE__ */ p(n, {
+					size: 24,
+					icon: /* @__PURE__ */ p(e.refresh, { size: 12 }),
+					onClick: () => _(r._key),
+					title: "Undo delete"
+				}) : /* @__PURE__ */ p(n, {
+					size: 24,
+					icon: /* @__PURE__ */ p(e.trash, { size: 12 }),
+					onClick: () => g(r._key),
+					title: "Delete row"
+				})
+			})
+		]
+	});
+}
+//#endregion
+export { w as DraggableChildrenTable };

package/dist-lib/Grid-Cwxca9aO.js

@@ -401,5 +401,3 @@ function re({ file: e, hasPrev: t, hasNext: n, onPrev: r, onNext: a, onClose: o
 }
 //#endregion
 export { D as Grid };
-
-//# sourceMappingURL=Grid-Cwxca9aO.js.map

package/dist-lib/JsonEditor-KelPV-OQ.js

@@ -63,5 +63,3 @@ function o({ value: o, onChange: s, readOnly: c, id: l }) {
 }
 //#endregion
 export { o as JsonEditor };
-
-//# sourceMappingURL=JsonEditor-KelPV-OQ.js.map

package/dist-lib/MarkdownRenderer-Dbl3AFDQ.js

@@ -96,5 +96,3 @@ function h({ content: e, plugins: n = "breaks", files: i, components: a, skipHtm
 }
 //#endregion
 export { h as MarkdownRenderer };
-
-//# sourceMappingURL=MarkdownRenderer-Dbl3AFDQ.js.map

package/dist-lib/api/data.d.ts

@@ -77,7 +77,7 @@ export declare class ActionBatchError extends Error {
  * ctx.ObjectIDs). The legacy `_ids` envelope was removed in Task 5;
  * passing it triggers a 400 from the server.
  */
-export declare function buildActionBody(params: Record<string, unknown> | undefined, ids?: string[] | undefined): ActionExecuteRequest;
+export declare function buildActionBody(params: Record<string, unknown> | undefined, ids?: string[]): ActionExecuteRequest;
 /**
  * Invoke an action. The URL `code` must be fully qualified for
  * entity-scoped actions (e.g. `lead.archive`). For global actions it's the

package/dist-lib/components/detail-layout/DetailAuditStrip.d.ts

@@ -1,11 +1,11 @@
 import type { Entity, Schema, Screen } from "../../types/schema";
-import type { RefsMap } from "../../components/fields";
+import type { Refs } from "../../components/fields";
 interface DetailAuditStripProps {
     screen: Screen;
     entity: Entity;
     entityCode: string;
     record: Record<string, unknown>;
-    refs?: RefsMap;
+    refs?: Refs;
     schema: Schema;
     locale: string;
 }

package/dist-lib/components/detail-layout/DetailHighlights.d.ts

@@ -1,12 +1,12 @@
 import type { Entity, Schema, Screen } from "../../types/schema";
 import type { StatusInfo } from "../../types/api";
-import type { RefsMap } from "../../components/fields";
+import type { Refs } from "../../components/fields";
 interface DetailHighlightsProps {
     screen: Screen;
     entity: Entity;
     entityCode: string;
     record: Record<string, unknown>;
-    refs?: RefsMap;
+    refs?: Refs;
     objectStatuses?: StatusInfo[];
     schema: Schema;
     locale: string;

package/dist-lib/components/detail-layout/DraggableChildrenTable.d.ts

@@ -1,5 +1,5 @@
 import type { Entity, Schema } from "../../types/schema";
-import type { RefsMap } from "../../components/fields";
+import type { Refs } from "../../components/fields";
 import type { PendingChildRow } from "./LayoutRenderer";
 import type { ResolvedChildConfig } from "../../lib/child-config";
 interface DraggableChildrenTableProps {
@@ -9,7 +9,7 @@ interface DraggableChildrenTableProps {
     rows: PendingChildRow[];
     onChange: (rows: PendingChildRow[]) => void;
     validationErrors?: Record<string, string[]>;
-    refs?: RefsMap;
+    refs?: Refs;
 }
 export declare function DraggableChildrenTable({ config, childEntity, schema, rows, onChange, validationErrors, refs, }: DraggableChildrenTableProps): import("react").JSX.Element;
 export {};

package/dist-lib/components/detail-layout/EditableChildrenTable.d.ts

@@ -1,5 +1,5 @@
 import type { Entity, Schema } from "../../types/schema";
-import type { RefsMap } from "../../components/fields";
+import type { Refs } from "../../components/fields";
 import type { PendingChildRow } from "./LayoutRenderer";
 import type { ResolvedChildConfig } from "../../lib/child-config";
 interface EditableChildrenTableProps {
@@ -9,7 +9,7 @@ interface EditableChildrenTableProps {
     rows: PendingChildRow[];
     onChange: (rows: PendingChildRow[]) => void;
     validationErrors?: Record<string, string[]>;
-    refs?: RefsMap;
+    refs?: Refs;
 }
 export declare function EditableChildrenTable({ config, childEntity, schema, rows, onChange, validationErrors, refs, }: EditableChildrenTableProps): import("react").JSX.Element;
 export {};

package/dist-lib/components/detail-layout/LayoutRenderer.d.ts

@@ -1,6 +1,6 @@
 import type { Entity, LayoutNode, Schema } from "../../types/schema";
 import type { StatusInfo, PropertyValue } from "../../types/api";
-import type { RefsMap } from "../../components/fields";
+import type { Refs } from "../../components/fields";
 export interface PendingChildRow {
     _key: string;
     _deleted?: boolean;
@@ -16,7 +16,7 @@ export interface LayoutContext {
     isNew: boolean;
     mode: "display" | "edit";
     onFieldChange?: (field: string, value: unknown) => void;
-    refs?: RefsMap;
+    refs?: Refs;
     columns?: number;
     objectProperties?: PropertyValue[];
     onSetProperty?: (propertyCode: string, value: unknown) => void;

package/dist-lib/components/fields/cells/registry.d.ts

@@ -1,9 +1,9 @@
 import type { ReactElement } from "react";
 import type { EntityField, Entity, Screen } from "../../../types/schema";
-export type RowRecord = Record<string, unknown>;
+import type { RowData, Refs } from "../../../types/api";
+export type { RowData, Refs };
 export type CellOutput = string | number | ReactElement;
-export type CellRenderer = (value: unknown, record: RowRecord) => CellOutput;
-export type RefsMap = Record<string, Record<string, Record<string, unknown>>>;
+export type CellRenderer = (value: unknown, record: RowData) => CellOutput;
 export interface CellResolveCtx {
     field: EntityField;
     fieldName: string;
@@ -11,7 +11,7 @@ export interface CellResolveCtx {
     entity?: Entity;
     entities?: Record<string, Entity>;
     screens?: Record<string, Screen>;
-    refs?: RefsMap | (() => RefsMap | undefined);
+    refs?: Refs | (() => Refs | undefined);
     locale: string;
 }
 export type CellFactory = (ctx: CellResolveCtx) => CellRenderer;

package/dist-lib/components/fields/index.d.ts

@@ -1,6 +1,7 @@
 import type { EntityField, Entity, Screen } from "../../types/schema";
 import { type FieldType } from "../../types/fieldType";
-export type RefsMap = Record<string, Record<string, Record<string, unknown>>>;
+import type { Refs } from "../../types/api";
+export type { Refs };
 export interface FieldRendererProps {
     field: EntityField;
     entityCode?: string;
@@ -11,7 +12,7 @@ export interface FieldRendererProps {
     fieldId?: string;
     labelId?: string;
     record?: Record<string, unknown>;
-    refs?: RefsMap;
+    refs?: Refs;
     fill?: boolean;
     compact?: boolean;
     surface?: "list" | "detail";
@@ -23,4 +24,3 @@ export interface FieldRendererProps {
 type FieldRenderer = React.ComponentType<FieldRendererProps>;
 export declare const editRegistry: Record<FieldType, FieldRenderer>;
 export declare function renderField(props: FieldRendererProps): React.ReactNode;
-export {};

package/dist-lib/components/file-widgets/host.d.ts

@@ -1,7 +1,7 @@
 import type { ReactNode } from "react";
 import type { Entity, Screen } from "../../types/schema";
 import type { FileFieldDef, FileFieldValue } from "../../types/files";
-import type { RefsMap } from "../../components/fields";
+import type { Refs } from "../../components/fields";
 export declare function getEntityFileField(entity: Pick<Entity, "files">, fieldName: string): FileFieldDef | undefined;
 export declare function getFileFieldValue(record: Record<string, unknown>, fieldName: string): FileFieldValue;
 export declare function getSchemaFieldValue(entity: Pick<Entity, "fields" | "files">, record: Record<string, unknown>, fieldName: string): unknown;
@@ -14,7 +14,7 @@ export declare function renderSchemaField(props: {
     record: Record<string, unknown>;
     mode: "display" | "edit";
     onChange?: (value: unknown) => void;
-    refs?: RefsMap;
+    refs?: Refs;
     disabled?: boolean;
     surface?: "list" | "detail";
     entities?: Record<string, Entity>;

package/dist-lib/components/filters/FilterDrawer.d.ts

@@ -2,7 +2,7 @@ import { type FilterNode, type FilterOp } from "../../lib/filters";
 export interface FilterFieldMeta {
     code: string;
     label: string;
-    type: "string" | "enum" | "int" | "float" | "date" | "timestamp" | "bool" | "ref" | "status" | "property" | string;
+    type: "string" | "enum" | "int" | "float" | "date" | "timestamp" | "bool" | "ref" | "status" | "property" | (string & {});
     operators: FilterOp[];
     options?: {
         value: string;

package/dist-lib/components/list/PeekFieldCell.d.ts

@@ -1,4 +1,4 @@
-import { type RefsMap } from "../../components/fields";
+import { type Refs } from "../../components/fields";
 import type { EntityField } from "../../types/schema";
 export interface PeekFieldCellProps {
     field: EntityField;
@@ -8,7 +8,7 @@ export interface PeekFieldCellProps {
     label: string;
     value: unknown;
     record?: Record<string, unknown>;
-    refs?: RefsMap;
+    refs?: Refs;
     readOnly?: boolean;
     /** Fired exactly once per explicit user commit. */
     onCommit: (next: unknown) => void;

package/dist-lib/components/list/QuickPeek.d.ts

@@ -1,6 +1,6 @@
 import { type ReactNode } from "react";
 import { type Action, type Entity, type EntityField, type Screen } from "../../types/schema";
-import type { RefsMap } from "../../components/fields";
+import type { Refs } from "../../components/fields";
 export interface QuickPeekRegularFieldSpec {
     key: string;
     label: string;
@@ -24,7 +24,7 @@ export interface QuickPeekProps<R extends Record<string, unknown> = Record<strin
     avatarName?: string;
     fields: QuickPeekFieldSpec[];
     /** $refs payload from the list/detail API; used by RefField-style renderers. */
-    refs?: RefsMap;
+    refs?: Refs;
     /** Full screen YAML — honors `screen.quick_peek.width` and `quick_peek.primary_action`. */
     screen?: Screen;
     /** All actions available on this record. */

package/dist-lib/components/mass-edit/PropertyGridEditor.d.ts

@@ -16,5 +16,5 @@ interface PropertyGridEditorProps {
 /** UI-only marker for cells whose selected rows disagree on the current value. */
 declare const MULTIPLE_VALUES: unique symbol;
 export declare function PropertyGridEditor({ entity, filterTargets, selectedRows, value, onChange, }: PropertyGridEditorProps): import("react").JSX.Element;
-export declare function detectCommonValue(target: MassEditTarget, selectedRows: ReadonlyArray<Record<string, unknown>> | undefined): unknown | typeof MULTIPLE_VALUES;
+export declare function detectCommonValue(target: MassEditTarget, selectedRows: ReadonlyArray<Record<string, unknown>> | undefined): unknown;
 export { MULTIPLE_VALUES };

package/dist-lib/components/pages/SmartListPage.d.ts

@@ -1,36 +1,12 @@
+import { type RowData } from "../../types/api";
 import type { Entity, PkValues } from "../../types/schema";
 interface SmartListPageProps {
     screenCode: string;
 }
-type RowData = Record<string, unknown>;
 export declare const PER_PAGE_MAX = 1000;
 export declare const PER_PAGE_DEFAULT = 200;
 export declare const PER_PAGE_OPTIONS: readonly [25, 50, 100, 200, 500, 1000];
 export declare function rowSelectionKey(entity: Entity, row: RowData): string;
 export declare function selectedRowPkValues(entity: Entity | undefined, rows: RowData[], selectedKeys: string[]): PkValues[];
-/**
- * Resolve the target href for a row click on a list screen per the
- * entity-canonical DSL. `list.detail_screen` is tri-valued:
- *
- *   absent                              -> inherit entity.detail_screen
- *   DETAIL_SCREEN_NONE ("none")         -> explicit opt-out (disabled)
- *   any other code                      -> override with that detail screen
- *
- * Resolution:
- *   if list.detail_screen === "none"    -> null (disabled)
- *   elif list.detail_screen is set      -> use screens[list.detail_screen]
- *   elif entity.detail_screen is set    -> use screens[entity.detail_screen]
- *   else                                -> null (disabled)
- *
- * Returns null when no navigation target exists; callers MUST render
- * non-interactive rows in that case (no cursor, no click handler).
- */
-export declare function resolveDetailHref(list: {
-    detail_screen?: string;
-}, id: string, entity: {
-    detail_screen?: string;
-} | undefined, allScreens: Record<string, {
-    route?: string;
-}> | undefined): string | null;
 export declare function SmartListPage({ screenCode }: SmartListPageProps): import("react").JSX.Element;
 export {};

package/dist-lib/components/pages/list/DataCell.d.ts

@@ -1,7 +1,6 @@
 import type { Cell } from "@tanstack/react-table";
-type RowData = Record<string, unknown>;
+import type { RowData } from "../../../types/api";
 export declare function DataCell({ cell, isRowSelected, }: {
     cell: Cell<RowData, unknown>;
     isRowSelected: boolean;
 }): import("react").JSX.Element;
-export {};

package/dist-lib/components/pages/list/columns.d.ts

@@ -1,8 +1,8 @@
 import { type RefObject } from "react";
 import type { ColumnDef } from "@tanstack/react-table";
-import { type RefsMap } from "../../../components/fields/cells/registry";
+import { type Refs } from "../../../components/fields/cells/registry";
 import type { Action, Entity, Screen } from "../../../types/schema";
-type RowData = Record<string, unknown>;
+import type { RowData } from "../../../types/api";
 type SchemaMaps = {
     entities?: Record<string, Entity>;
     screens?: Record<string, Screen>;
@@ -33,7 +33,7 @@ export interface BuildListColumnsArgs {
     }) => void;
     /** Latest $refs payload, read through a ref so column identity is stable
      *  across data fetches (see SmartListPageInner refsRef comment). */
-    refsRef: RefObject<RefsMap | undefined>;
+    refsRef: RefObject<Refs | undefined>;
     /** Row-selection key, used as the stable rowId for per-row action dispatch. */
     rowSelectionKey: (entity: Entity, row: RowData) => string;
     setPeekRow: (row: RowData) => void;

package/dist-lib/components/primitives/index.d.ts

@@ -1,4 +1,3 @@
-export { cx } from "./cx";
 export { Icon } from "./Icons";
 export type { IconProps, IconName } from "./Icons";
 export { Btn } from "./Btn";

package/dist-lib/components/shared/ActionRunner.d.ts

@@ -8,8 +8,9 @@ export interface RunActionOptions {
     /** When `action` is absent, individual flags still steer dispatch. */
     destructive?: boolean;
     longRunning?: boolean;
-    /** Invoked after the user confirms / fills params. */
-    execute: (params: Record<string, unknown>) => Promise<unknown> | unknown;
+    /** Invoked after the user confirms / fills params. May return a promise
+     *  (awaited by the runner) or a sync value; `unknown` covers both. */
+    execute: (params: Record<string, unknown>) => unknown;
     /**
      * Caller-side hook fired after `execute` resolves with a `success`
      * outcome. Reason: navigation and cache-invalidation decisions that

package/dist-lib/components/shared/Breadcrumbs.d.ts

@@ -1,7 +1,7 @@
 import { type IconName } from "../../components/primitives";
 export interface Crumb {
     label: string;
-    icon?: IconName | string;
+    icon?: IconName | (string & {});
     onClick?: () => void;
     target?: unknown;
     /** True for the final segment (rendered bold per design spec). */