@atscript/vue-table 0.1.142 → 0.1.144

package/dist/{use-table-state-BiklfjP0.cjs → use-table-state-Ddr2UZzB.cjs}

@@ -22,79 +22,169 @@ function actionNamesOf(row) {
 	return Array.isArray(raw) ? raw : null;
 }
 /**
-* Predicate factory: an action is available when its name is in `allowed`. The
-* synthesised remove action (`REMOVE_PROCESSOR`) is the sole exemption — it is
-* built client-side and its name never appears in the server's `$actions`, so
-* its visibility is governed by `canRemove` (the server still authorises the
-* actual delete at call time). Shared by the single-row and bulk gates.
+* A row's raw `$disabledReasons` object — action name → the reason its
+* `disabled` predicate returned for that row (`@atscript/db` 0.1.141+) — or
+* `null` when it is missing or not a plain object. Read lazily (no copy): the
+* gates look names up with {@link ownReason}.
 */
-function gateFor(allowed) {
-	return (a) => a.processor === "__remove" || allowed.has(a.name);
+function reasonsObjectOf(row) {
+	const raw = row?.$disabledReasons;
+	return raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw : null;
 }
 /**
-* Build a per-row availability predicate from `row.$actions`. Every
-* server-declared row/rows action — regardless of processor (`backend`,
-* `navigate`, `custom`, …) — is gated by its per-row `$actions` verdict: the
-* server augmenter evaluates each action's `disabled` predicate for the row and
-* emits the surviving names. Returns `null` when the row carries no `$actions`
+* `raw[name]` when it is an OWN non-empty string, else `undefined` — so an
+* action named after an `Object.prototype` member (`constructor`,
+* `toString`) never reads an inherited function as its verdict, and a
+* malformed value can never surface an action (it only decides between
+* disabled and hidden).
+*/
+function ownReason(raw, name) {
+	if (!Object.hasOwn(raw, name)) return void 0;
+	const reason = raw[name];
+	return typeof reason === "string" && reason !== "" ? reason : void 0;
+}
+/**
+* Apply one verdict to `a`: `false` → `undefined` (dropped), a non-empty
+* string → a COPY carrying `disabledReason` (shared source descriptors are
+* never mutated), anything else → `a` itself.
+*/
+function withVerdict(a, verdict) {
+	if (verdict === false) return void 0;
+	return typeof verdict === "string" && verdict !== "" ? {
+		...a,
+		disabledReason: verdict
+	} : a;
+}
+/**
+* Gate factory: an action is available when its name is in `allowed`; one
+* that is not but has a reason (`reasonOf`) is shown disabled with it; any
+* other is hidden (disabled without a reason). The synthesised remove action
+* (`REMOVE_PROCESSOR`) is the sole exemption — it is built client-side and its
+* name never appears in the server's `$actions`, so its visibility is
+* governed by `canRemove` (the server still authorises the actual delete at
+* call time). Shared by the single-row and bulk gates.
+*/
+function gateFor(allowed, reasonOf) {
+	return (a) => a.processor === "__remove" || allowed.has(a.name) || (reasonOf(a.name) ?? false);
+}
+const NO_REASON = () => void 0;
+/**
+* Build a per-row availability gate from `row.$actions` + `row.$disabledReasons`.
+* Every server-declared row/rows action — regardless of processor (`backend`,
+* `navigate`, `custom`, …) — is gated by its per-row verdict: the server
+* augmenter evaluates each action's `disabled` predicate for the row and emits
+* the surviving names, plus the reason of each action disabled WITH one.
+* In `$actions` → enabled; in `$disabledReasons` → disabled with the reason;
+* in neither → hidden. Returns `null` when the row carries no `$actions`
 * (see {@link actionNamesOf}).
 */
 function rowActionGate(row) {
 	const names = actionNamesOf(row);
-	return names ? gateFor(new Set(names)) : null;
+	if (!names) return null;
+	const raw = reasonsObjectOf(row);
+	return gateFor(new Set(names), raw ? (name) => ownReason(raw, name) : NO_REASON);
 }
 /**
-* Walk a `{default, others, rows}` triple once: keep the actions `gate`
-* admits, then run each survivor through `map`. Both are optional — with
-* neither, the input `buckets` reference comes back unchanged so source-array
-* references stay stable downstream (no spurious recomputes in consumers that
-* compare array identity). Shared by the single-row (`applyRowGate`), bulk
+* `true` when `action` is a gated copy kept DISABLED (`disabledReason`) —
+* rendered, never triggered. The one predicate every surface checks.
+*/
+function isActionDisabled(action) {
+	return !!action.disabledReason;
+}
+/**
+* Walk a `{default, others, rows}` triple once: apply `gate`'s verdict to
+* each action ({@link withVerdict}), then run each survivor through `map`.
+* Both are optional. Source references stay stable downstream (no spurious
+* recomputes in consumers that compare array identity): an array whose every
+* action comes back unchanged is returned as is, and so is the whole
+* `buckets` object when nothing changed. Shared by the single-row, bulk
 * (`applyRowsGate`) and per-screen-policy paths.
 */
 function applyGate(buckets, gate, map) {
 	if (!gate && !map) return buckets;
-	const keep = gate ?? (() => true);
+	const admit = (a) => {
+		const kept = gate ? withVerdict(a, gate(a)) : a;
+		return kept && map ? map(kept) : kept;
+	};
 	const walk = (list) => {
-		const kept = gate ? list.filter(keep) : list;
-		return map ? kept.map(map) : kept;
+		let out = null;
+		for (let i = 0; i < list.length; i++) {
+			const a = list[i];
+			const kept = admit(a);
+			if (out === null) {
+				if (kept === a) continue;
+				out = list.slice(0, i);
+			}
+			if (kept) out.push(kept);
+		}
+		return out ?? list;
 	};
-	const def = buckets.default;
-	return {
-		default: def && keep(def) ? map ? map(def) : def : void 0,
-		others: walk(buckets.others),
-		rows: walk(buckets.rows)
+	const def = buckets.default && admit(buckets.default);
+	const others = walk(buckets.others);
+	const rows = walk(buckets.rows);
+	return def === buckets.default && others === buckets.others && rows === buckets.rows ? buckets : {
+		default: def,
+		others,
+		rows
 	};
 }
-/**
-* Apply the single-row {@link rowActionGate} to a `{default, others, rows}`
-* triple; identity-stable when the row carries no `$actions` (see {@link applyGate}).
-*/
-function applyRowGate(buckets, row) {
-	return applyGate(buckets, rowActionGate(row));
+/** Distinct reasons listed on a bulk surface before the rest collapse into "+N more". */
+const MAX_BULK_REASONS = 3;
+function joinReasons(reasons) {
+	const list = [...reasons];
+	if (list.length <= MAX_BULK_REASONS) return list.join("; ");
+	const rest = list.length - MAX_BULK_REASONS;
+	return `${list.slice(0, MAX_BULK_REASONS).join("; ")}; +${rest} more`;
 }
 /**
-* Build a BULK availability predicate from the UNION of every selected row's
-* server `$actions`: an action is shown when AT LEAST ONE selected row allows
-* it, even if absent from the rest. This is safe because the `@atscript/db`
-* layer re-filters each row server-side at invoke time, so a subset-enabled
-* action simply no-ops on the rows that don't qualify — strictly better UX
-* than hiding an action a portion of the selection can use. The synthesised
-* remove action (`REMOVE_PROCESSOR`) is the sole exemption: it is built
-* client-side and never appears in any server `$actions`. Returns `null` when
-* NO selected row carries a `$actions` array (legacy server / `?$actions`
-* opt-out) so callers skip the filter pass and keep array identity stable;
-* rows with an empty `$actions: []` still count as "the server spoke" and
-* therefore disable normal actions.
+* Build a BULK availability gate from the UNION of every selected row's
+* server `$actions`: an action is enabled when AT LEAST ONE selected row allows
+* it, even if absent from the rest. The server re-checks every row at invoke
+* time (`onDisabledRows`: `'skip'` runs on the qualifying rows, `'reject'` —
+* the default — answers 409 with the per-row reasons, surfaced as the
+* action's error result), so offering an action part of the selection can use
+* is strictly better UX than hiding it. An action NO selected row allows is
+* shown disabled when at least one row gave a reason (the distinct reasons
+* joined, capped at {@link MAX_BULK_REASONS}), hidden otherwise. The
+* synthesised remove action (`REMOVE_PROCESSOR`) is the sole exemption: it is
+* built client-side and never appears in any server `$actions`. Returns `null`
+* when NO row carries a `$actions` array (legacy server / `?$actions` opt-out)
+* so callers skip the filter pass and keep array identity stable; rows with an
+* empty `$actions: []` still count as "the server spoke" and therefore disable
+* normal actions. Pass only rows that are loaded — see `state.selectedRowObjects`.
 */
 function rowsActionGate(rows) {
 	let union = null;
+	let reasons = null;
 	for (const row of rows) {
 		const names = actionNamesOf(row);
 		if (!names) continue;
-		if (union === null) union = /* @__PURE__ */ new Set();
+		union ??= /* @__PURE__ */ new Set();
 		for (const name of names) union.add(name);
+		const raw = reasonsObjectOf(row);
+		if (!raw) continue;
+		for (const name of Object.keys(raw)) {
+			const reason = raw[name];
+			if (typeof reason !== "string" || reason === "") continue;
+			reasons ??= /* @__PURE__ */ new Map();
+			let set = reasons.get(name);
+			if (!set) reasons.set(name, set = /* @__PURE__ */ new Set());
+			set.add(reason);
+		}
 	}
-	return union ? gateFor(union) : null;
+	if (!union) return null;
+	if (!reasons) return gateFor(union, NO_REASON);
+	const byName = reasons;
+	const joined = /* @__PURE__ */ new Map();
+	return gateFor(union, (name) => {
+		let text = joined.get(name);
+		if (text === void 0) {
+			const set = byName.get(name);
+			if (!set) return void 0;
+			joined.set(name, text = joinReasons(set));
+		}
+		return text;
+	});
 }
 /**
 * Apply the BULK union gate to a `{default, others, rows}` triple. See
@@ -148,35 +238,64 @@ function extractIdentifier(source, preferredId) {
 }
 /**
 * Map a list of sources (full row objects or scalar `rowValueFn` values)
-* through `extractIdentifier`. Scalar sources rehydrate from
-* `state.windowCache` via `state.rowValueFn` so consumers that override
-* `rowValueFn` to return a scalar can still reconstruct multi-field
-* identifiers; the lookup `Map` is built lazily so all-object source
-* lists pay nothing.
+* through `extractIdentifier`. Scalar sources resolve to their loaded row via
+* `state.rowOf` so consumers that override `rowValueFn` to return a scalar
+* can still reconstruct multi-field identifiers; a scalar whose row is not
+* loaded falls back to itself (a single-field `preferredId` wraps it).
 */
 function collectIdentifiers(state, sources, preferredId) {
 	if (preferredId.length === 0 || sources.length === 0) return [];
 	const out = [];
-	let lookup = null;
 	for (const s of sources) {
 		if (s === void 0 || s === null) continue;
-		let row;
-		if (typeof s === "object") row = s;
-		else {
-			if (lookup === null) {
-				const fn = state.rowValueFn;
-				lookup = /* @__PURE__ */ new Map();
-				for (const r of state.windowCache.value.values()) lookup.set(fn(r), r);
-			}
-			row = lookup.get(s);
-		}
-		const id = extractIdentifier(row ?? s, preferredId);
+		const id = extractIdentifier(state.rowOf(s) ?? s, preferredId);
 		if (id) out.push(id);
 	}
 	return out;
 }
+/**
+* Accessible name of an action trigger. A disabled action appends its reason
+* (`"Ship, Order already shipped"` — the same `label, reason` shape as the
+* selection checkbox of a non-selectable row), so screen readers announce WHY
+* next to the disabled state.
+*/
 function ariaLabelFor(action) {
-	return action.label || action.name;
+	const label = action.label || action.name;
+	return action.disabledReason ? `${label}, ${action.disabledReason}` : label;
+}
+/** `aria-disabled` value for a rendered action — `"true"` on a disabled copy, else unset. */
+function ariaDisabled(action) {
+	return isActionDisabled(action) ? "true" : void 0;
+}
+/**
+* Whether a trigger renders as a real anchor: it has a resolved `href` and no
+* `promptText` (a confirm dialog must guard the navigation, so a prompted
+* action stays a button — mod/middle-click on it still confirms → new tab).
+* A disabled action never has an href (see `rowActionHref`), so it is never
+* a link.
+*/
+function isLinkTrigger(action, href) {
+	return href !== void 0 && !action.promptText;
+}
+/**
+* Element + attributes of a primary action trigger (the single row-actions
+* button, the toolbar default) — the one home for anchor-vs-button and the
+* disabled rendering: a disabled action is an `aria-disabled` button (kept
+* focusable so the reason in its accessible name / tooltip stays reachable).
+*/
+function triggerBindings(action, href) {
+	const asLink = isLinkTrigger(action, href);
+	const label = ariaLabelFor(action);
+	return {
+		tag: asLink ? "a" : "button",
+		attrs: {
+			href: asLink ? href : void 0,
+			type: asLink ? void 0 : "button",
+			"aria-disabled": ariaDisabled(action),
+			"aria-label": label,
+			title: label
+		}
+	};
 }
 /**
 * Compose the runtime intent class — `as-{prefix}-intent-{intent}` — applied
@@ -222,6 +341,7 @@ function actionHref(state, action, id) {
 * owns the navigation.
 */
 async function openNavigateInNewTab(state, action, ctx, href) {
+	if (isActionDisabled(action)) return;
 	if (!await confirmAction(state, action, ctx)) return;
 	window.open(href, "_blank", "noopener,noreferrer");
 }
@@ -230,12 +350,14 @@ async function openNavigateInNewTab(state, action, ctx, href) {
 * shared by `<AsRowActions>` and `<AsTableActions>`. Parameterized only by
 * the surface's prompt-context getter and href resolver so the click-dispatch
 * policy — plain left → SPA invoke, cmd/ctrl or middle on a promptText
-* navigate button → confirm → new tab — has a single home.
+* navigate button → confirm → new tab — has a single home. A disabled
+* action needs no guard here: it has no href (`rowActionHref`), and the
+* invoke path ends in `triggerAction`, which refuses it.
 */
 function createNavigateGestures(state, promptCtx, hrefFor) {
 	return {
-		onTriggerClick(action, href, asLink, event) {
-			if (asLink) {
+		onTriggerClick(action, href, event) {
+			if (isLinkTrigger(action, href)) {
 				if (!isPlainLeftClick(event)) return;
 				event.preventDefault();
 			} else if (href !== void 0 && isModClick(event)) {
@@ -244,8 +366,8 @@ function createNavigateGestures(state, promptCtx, hrefFor) {
 			}
 			triggerAction(state, action, promptCtx(), event);
 		},
-		onTriggerAuxClick(action, href, asLink, event) {
-			if (asLink || href === void 0 || event.button !== 1) return;
+		onTriggerAuxClick(action, href, event) {
+			if (href === void 0 || isLinkTrigger(action, href) || event.button !== 1) return;
 			event.preventDefault();
 			openNavigateInNewTab(state, action, promptCtx(), href);
 		},
@@ -280,9 +402,13 @@ function substitute(template, ctx) {
 /**
 * Dispatch user-initiated invocation: actions with `inputForm` open the form
 * dialog (the form IS the confirm surface, so `promptText` is ignored);
-* others run `confirmAction()`. Cancelling either dialog short-circuits.
+* others run `confirmAction()`. Cancelling either dialog short-circuits. A
+* disabled action (`disabledReason`) never runs: this is the choke point
+* every built-in trigger — and a custom slot's `invoke` — funnels through
+* (the other is `rowActionHref`, which gives it no link to follow).
 */
 async function triggerAction(state, action, ctx, event) {
+	if (isActionDisabled(action)) return;
 	const pk = pkForLevel(action.level, ctx.identifiers);
 	if (action.inputForm) {
 		const input = await state.requestActionInput(action, ctx);
@@ -344,9 +470,12 @@ function toLocalActionInfo(local) {
 * action builds its own from the row — still mapped through
 * `state.resolveHref`, so router base paths apply exactly as they do for a
 * server `navigate` action — and a server action goes through
-* {@link actionHref}.
+* {@link actionHref}. A disabled action has none — one of the two disabled
+* choke points (the other is `triggerAction`): no href means no anchor, no
+* new-tab gesture, nothing to follow.
 */
 function rowActionHref(state, action, id, row) {
+	if (isActionDisabled(action)) return void 0;
 	const local = localActionOf(action);
 	if (local) return local.href && row !== void 0 ? state.resolveHref(local.href(row)) : void 0;
 	return actionHref(state, action, id);
@@ -354,7 +483,7 @@ function rowActionHref(state, action, id, row) {
 const EMPTY = Object.freeze([]);
 /** The identity policy — used when no `RowActionsConfig` is wired. */
 const PASS_THROUGH = {
-	apply: (buckets) => buckets,
+	apply: (buckets, rowGate) => applyGate(buckets, rowGate ?? null),
 	extra: () => EMPTY
 };
 /** Compile a per-screen {@link RowActionsConfig} into a {@link RowActionsPolicy}. */
@@ -363,7 +492,7 @@ function compileRowActionsConfig(config) {
 	const include = config.include ? new Set(config.include) : null;
 	const exclude = config.exclude ? new Set(config.exclude) : null;
 	const overrides = config.overrides;
-	const gate = (a) => (!include || include.has(a.name)) && !exclude?.has(a.name);
+	const allowed = (a) => (!include || include.has(a.name)) && !exclude?.has(a.name);
 	const decorate = overrides ? (action) => {
 		const patch = overrides[action.name];
 		if (!patch) return action;
@@ -379,15 +508,46 @@ function compileRowActionsConfig(config) {
 		}
 		return next;
 	} : void 0;
-	const locals = (config.extra ?? []).filter((local) => !exclude?.has(local.name));
+	const locals = (config.extra ?? []).filter((local) => !exclude?.has(local.name)).map(toLocalActionInfo);
 	return {
-		apply: (buckets) => applyGate(buckets, gate, decorate),
+		apply: (buckets, rowGate) => applyGate(buckets, rowGate ? (a) => {
+			const verdict = rowGate(a);
+			return verdict !== false && allowed(a) ? verdict : false;
+		} : allowed, decorate),
 		extra: (row) => {
 			if (locals.length === 0) return EMPTY;
-			return (row === void 0 ? locals : locals.filter((l) => l.enabled?.(row) !== false)).map(toLocalActionInfo);
+			if (row === void 0) return locals;
+			return applyGate({
+				default: void 0,
+				others: locals,
+				rows: EMPTY
+			}, (a) => a.$local.enabled?.(row) ?? true).others;
 		}
 	};
 }
+/**
+* The row actions a surface renders for `row` — the one shared per-row
+* pipeline behind `<AsRowActions>`, the `<AsTableActions>` row level and the
+* Enter / double-click main-action fallback: the row's server gate
+* (`$actions` / `$disabledReasons`) and the root's `:row-actions` policy in a
+* single pass, plus the policy's app-owned `extra` actions. Pass
+* `withRows: false` to leave out the rows-level bucket.
+*/
+function resolveRowActions(state, row, opts) {
+	const policy = state.rowActionsPolicy.value;
+	const { actions } = state;
+	const gated = policy.apply({
+		default: actions.default.row,
+		others: actions.others.row,
+		rows: opts?.withRows === false ? EMPTY : actions.rows
+	}, rowActionGate(row));
+	return {
+		default: gated.default,
+		others: gated.others,
+		rows: gated.rows,
+		extra: policy.extra(row)
+	};
+}
 //#endregion
 //#region src/composables/state/create-actions.ts
 const REMOVE_NAME = REMOVE_PROCESSOR;
@@ -581,10 +741,28 @@ function verdictOf(value) {
 		reason: value
 	} : NOT_SELECTABLE;
 }
-function createSelectionApi(opts, getActiveRow, activeIndex) {
+function createSelectionApi(opts, getActiveRow, activeIndex, windowCache) {
 	const selectedRows = opts?.selectedRows ?? (0, vue.shallowRef)([]);
 	const selectedCount = (0, vue.computed)(() => selectedRows.value.length);
 	const rowValueFn = opts?.rowValueFn ?? ((row) => row);
+	const rowByValue = (0, vue.computed)(() => {
+		const map = /* @__PURE__ */ new Map();
+		for (const row of windowCache.value.values()) map.set(rowValueFn(row), row);
+		return map;
+	});
+	function rowOf(value) {
+		if (value === void 0 || value === null) return void 0;
+		if (typeof value === "object") return value;
+		return rowByValue.value.get(value);
+	}
+	const selectedRowObjects = (0, vue.computed)(() => {
+		const out = [];
+		for (const value of selectedRows.value) {
+			const row = rowOf(value);
+			if (row) out.push(row);
+		}
+		return out;
+	});
 	const selectedSet = (0, vue.computed)(() => new Set(selectedRows.value));
 	function isPkSelected(pk) {
 		return selectedSet.value.has(pk);
@@ -650,6 +828,9 @@ function createSelectionApi(opts, getActiveRow, activeIndex) {
 		selectedCount,
 		selectedSet,
 		rowValueFn,
+		rowByValue,
+		rowOf,
+		selectedRowObjects,
 		isPkSelected,
 		rowSelectable,
 		isRowSelectable,
@@ -667,8 +848,8 @@ function createSelectionApi(opts, getActiveRow, activeIndex) {
 /**
 * Listener registry for the `main-action` event. When listeners are present,
 * `requestMainAction` builds a `MainActionRequest` and dispatches it. When no
-* listener is registered, falls back to invoking `actions.default.row` against
-* the active row's PK (if both are defined). The fallback path SHALL NOT
+* listener is registered and the table declares a default row action, it
+* hands the active row to `invokeFallback`. The fallback path SHALL NOT
 * construct a `MainActionRequest` payload — there is nothing to receive it.
 */
 function createMainActionRegistry(opts) {
@@ -700,8 +881,7 @@ function createMainActionRegistry(opts) {
 			for (const cb of listeners) cb(req);
 			return;
 		}
-		const fallback = opts.getDefaultRowAction?.();
-		if (fallback && opts.invokeFallback) opts.invokeFallback(fallback, row, event);
+		if (opts.invokeFallback && opts.getDefaultRowAction?.()) opts.invokeFallback(row, event);
 	}
 	return {
 		hasMainActionListener,
@@ -2007,7 +2187,7 @@ function createTableState(opts) {
 		if (idx < 0) return void 0;
 		return navMode.value === "window" ? dataAt(idx) : results.value[idx];
 	}
-	const { selectedRows, selectedCount, rowValueFn, isPkSelected, rowSelectable, isRowSelectable, selectableRows, selectableCount, selectAll, deselectAll, toggleAll, clearSelection, toggleActiveSelection } = createSelectionApi(selectionOpts, getActiveRow, activeIndex);
+	const { selectedRows, selectedCount, rowValueFn, rowByValue, rowOf, selectedRowObjects, isPkSelected, rowSelectable, isRowSelectable, selectableRows, selectableCount, selectAll, deselectAll, toggleAll, clearSelection, toggleActiveSelection } = createSelectionApi(selectionOpts, getActiveRow, activeIndex, windowCache);
 	const { actions } = createActions({
 		tableDef,
 		client,
@@ -2021,13 +2201,16 @@ function createTableState(opts) {
 		getActiveIndex: () => activeIndex.value,
 		getActiveRow,
 		getDefaultRowAction: () => actions.default.row,
-		invokeFallback: (action, row, event) => {
+		invokeFallback: (row, event) => {
 			if (!stateRef) return;
+			const action = resolveRowActions(stateRef, row, { withRows: false }).default;
+			if (!action) return;
 			const preferredId = tableDef.value?.preferredId ?? [];
 			const identifiers = collectIdentifiers(stateRef, [row], preferredId);
 			triggerAction(stateRef, action, {
 				identifiers,
-				preferredId
+				preferredId,
+				row
 			}, event);
 		}
 	});
@@ -2175,6 +2358,9 @@ function createTableState(opts) {
 		selectedRows,
 		selectedCount,
 		rowValueFn,
+		rowByValue,
+		rowOf,
+		selectedRowObjects,
 		resolveHref: opts.actions?.resolveHref ?? ((url) => url),
 		isPkSelected,
 		rowSelectable,
@@ -2709,16 +2895,16 @@ Object.defineProperty(exports, "ROW_ACTIONS_TYPE", {
 		return ROW_ACTIONS_TYPE;
 	}
 });
-Object.defineProperty(exports, "applyRowGate", {
+Object.defineProperty(exports, "applyRowsGate", {
 	enumerable: true,
 	get: function() {
-		return applyRowGate;
+		return applyRowsGate;
 	}
 });
-Object.defineProperty(exports, "applyRowsGate", {
+Object.defineProperty(exports, "ariaDisabled", {
 	enumerable: true,
 	get: function() {
-		return applyRowsGate;
+		return ariaDisabled;
 	}
 });
 Object.defineProperty(exports, "ariaLabelFor", {
@@ -2769,6 +2955,18 @@ Object.defineProperty(exports, "intentToScope", {
 		return intentToScope;
 	}
 });
+Object.defineProperty(exports, "isActionDisabled", {
+	enumerable: true,
+	get: function() {
+		return isActionDisabled;
+	}
+});
+Object.defineProperty(exports, "isLinkTrigger", {
+	enumerable: true,
+	get: function() {
+		return isLinkTrigger;
+	}
+});
 Object.defineProperty(exports, "isModClick", {
 	enumerable: true,
 	get: function() {
@@ -2805,6 +3003,12 @@ Object.defineProperty(exports, "readPresetLabel", {
 		return readPresetLabel;
 	}
 });
+Object.defineProperty(exports, "resolveRowActions", {
+	enumerable: true,
+	get: function() {
+		return resolveRowActions;
+	}
+});
 Object.defineProperty(exports, "rowActionHref", {
 	enumerable: true,
 	get: function() {
@@ -2829,6 +3033,12 @@ Object.defineProperty(exports, "triggerAction", {
 		return triggerAction;
 	}
 });
+Object.defineProperty(exports, "triggerBindings", {
+	enumerable: true,
+	get: function() {
+		return triggerBindings;
+	}
+});
 Object.defineProperty(exports, "useRegisterMainActionListener", {
 	enumerable: true,
 	get: function() {