@protobase/ui 0.26.6 → 0.26.8

package/dist/app/list-actions/row-record.js

@@ -0,0 +1,15 @@
+import { displayRow } from "../displays/list-displays.js";
+//#region src/app/list-actions/row-record.ts
+/**
+* A list's row as the record a named action acts on: its fields as the API gives them, without what the list loads
+* beside them, with its key, ETag and permissions.
+*/
+const rowRecord = (model, row) => ({
+	model,
+	record: Object.fromEntries(Object.entries(displayRow(model, row).record).filter(([name]) => Object.hasOwn(model.fields, name))),
+	key: row.id,
+	...typeof row.etag === "string" && { etag: row.etag },
+	...typeof row.permissions === "object" && row.permissions !== null && { permissions: row.permissions }
+});
+//#endregion
+export { rowRecord };

package/dist/app/list-actions/use-list-actions.js

@@ -0,0 +1,95 @@
+import { useAdminMeta } from "../meta-gate.js";
+import { useAppAddress } from "../use-app-address.js";
+import { ConfirmAction } from "../pages/confirm-action.js";
+import { isDanger } from "../pages/action-prompt.js";
+import { actionApplies } from "../pages/action-when.js";
+import { actionFor, linkTarget, openLink } from "../pages/action-href.js";
+import { useActionRunner } from "../pages/use-run-action.js";
+import { text } from "../list-messages.js";
+import { rowRecord } from "./row-record.js";
+import { useState } from "react";
+import { fillAddress } from "@protobase/schema/internal";
+import { jsx } from "react/jsx-runtime";
+//#region src/app/list-actions/use-list-actions.tsx
+/**
+* The named actions of `model`'s view for its list, those without inputs (which ask in a dialog of their own): each
+* in the row menu of the rows it shows for, disabled with its reason where `when` disables it, and in red when it is a
+* delete or a danger action; a link is a link there. Updates and handlers marked `bulk` are offered for a selection
+* while one selected row applies, and run on those that do. `prompt` is the question one asks before it runs.
+*/
+const useListActions = (model) => {
+	const { views } = useAdminMeta();
+	const runner = useActionRunner(model.name, void 0);
+	const { go, href } = useAppAddress();
+	const [asking, setAsking] = useState();
+	const listed = (views[model.name]?.actions ?? []).filter((action) => !action.inputs?.length);
+	const perform = (run) => "row" in run ? runner.run(run.action, run.row) : runner.runEach(run.action, run.selection, run.skipped);
+	const start = (run) => {
+		if (run.action.confirm) setAsking(run);
+		else perform(run);
+	};
+	return {
+		rowActions: listed.map((action) => {
+			const shown = (row) => actionFor(action, rowRecord(model, row).record);
+			const base = {
+				label: (row) => shown(row)?.label ?? action.label,
+				destructive: isDanger(action)
+			};
+			const run = action.run;
+			if (run?.kind === "link") {
+				const available = (row) => shown(row) !== void 0 && actionApplies(action, rowRecord(model, row).record);
+				if ("to" in run) {
+					const address = (row) => fillAddress(run.to, rowRecord(model, row).record);
+					return {
+						...base,
+						available,
+						link: (row) => ({
+							href: href(address(row)),
+							onFollow: () => go(address(row))
+						})
+					};
+				}
+				const target = (row) => linkTarget(run.href, rowRecord(model, row).record) ?? "";
+				return {
+					...base,
+					available,
+					link: (row) => ({
+						href: target(row),
+						onFollow: () => openLink(target(row))
+					})
+				};
+			}
+			return {
+				...base,
+				available: (row) => shown(row) !== void 0,
+				blocked: (row) => runner.blockedOn(action, rowRecord(model, row)),
+				onSelect: (row) => start({
+					action,
+					row: rowRecord(model, row)
+				})
+			};
+		}),
+		bulkActions: listed.filter((action) => action.bulk && action.run?.kind !== "link").map((action) => ({
+			label: (count) => text("actionCount", action.label, count),
+			destructive: isDanger(action),
+			available: (row) => runner.appliesOn(action, rowRecord(model, row)),
+			onRun: (rows, skipped) => start({
+				action,
+				selection: rows.map((row) => rowRecord(model, row)),
+				skipped
+			})
+		})),
+		prompt: asking && /* @__PURE__ */ jsx(ConfirmAction, {
+			action: asking.action,
+			label: asking.action.label,
+			danger: isDanger(asking.action),
+			onCancel: () => setAsking(void 0),
+			onConfirm: () => {
+				setAsking(void 0);
+				perform(asking);
+			}
+		})
+	};
+};
+//#endregion
+export { useListActions };

package/dist/app/list-messages.js

@@ -14,6 +14,7 @@ const text = defineMessages({
 		delete: "Delete",
 		exportCount: (count) => `Export ${count}`,
 		deleteCount: (count) => `Delete ${count}`,
+		actionCount: (label, count) => `${label} (${count})`,
 		dragToSort: "Drag a row by its handle to move it. Every move is saved as you drop it.",
 		unreadableFilter: "The filter in the address could not be read",
 		couldNotLoadRows: "Could not load rows",
@@ -38,6 +39,7 @@ const text = defineMessages({
 		delete: "Verwijderen",
 		exportCount: (count) => `${count} exporteren`,
 		deleteCount: (count) => `${count} verwijderen`,
+		actionCount: (label, count) => `${label} (${count})`,
 		dragToSort: "Sleep een rij aan de greep om hem te verplaatsen. Elke verplaatsing wordt bewaard zodra je loslaat.",
 		unreadableFilter: "Het filter in het adres kon niet worden gelezen",
 		couldNotLoadRows: "Kon de rijen niet laden",

package/dist/app/list-page.js

@@ -61,6 +61,7 @@ import { SavedList } from "./saved/saved-list.js";
 import { SaveSearchButton } from "./searches/save-search-button.js";
 import { SavedSearches } from "./searches/saved-searches.js";
 import { useListCellEditor } from "./list-edit/use-list-cell-editor.js";
+import { useListActions } from "./list-actions/use-list-actions.js";
 import { HandSortedList } from "./hand-order/hand-sorted-list.js";
 import { ReorderButton } from "./hand-order/reorder-button.js";
 import { useMemo, useState } from "react";
@@ -202,6 +203,8 @@ const LoadedList = ({ model, address, scope, heading }) => {
 			key: deleted.key
 		})
 	});
+	const named = useListActions(model);
+	const namedDelete = view?.actions.some((action) => action.run?.kind === "delete") ?? false;
 	const setFilter = (next, nextExtras = extras) => set({ filter: stateToText(fields, next, nextExtras) });
 	const search = searchText(extras);
 	const commitSearch = (text) => {
@@ -357,23 +360,31 @@ const LoadedList = ({ model, address, scope, heading }) => {
 		rowPatches: cellEditing.patches,
 		initialScrollIndex: scroll.initialIndex,
 		onScrollIndex: scroll.remember,
-		rowActions: [{
-			label: text$1("openRecord", singular),
-			onSelect: openRecord
-		}, ...can(permissions, "delete") ? [{
-			label: text$1("delete"),
-			destructive: true,
-			available: (row) => rowAllows(row, "delete"),
-			onSelect: (row) => void remove.start(target(row))
-		}] : []],
-		bulkActions: [...exportOffered(view) && exportsSelection(model) ? [{
-			label: (count) => text$1("exportCount", count),
-			onRun: (rows) => exportFlow.open(rows)
-		}] : [], ...can(permissions, "delete") ? [{
-			label: (count) => text$1("deleteCount", count),
-			destructive: true,
-			onRun: (rows) => remove.startBulk(rows.map(target))
-		}] : []],
+		rowActions: [
+			{
+				label: text$1("openRecord", singular),
+				onSelect: openRecord
+			},
+			...named.rowActions,
+			...can(permissions, "delete") && !namedDelete ? [{
+				label: text$1("delete"),
+				destructive: true,
+				available: (row) => rowAllows(row, "delete"),
+				onSelect: (row) => void remove.start(target(row))
+			}] : []
+		],
+		bulkActions: [
+			...exportOffered(view) && exportsSelection(model) ? [{
+				label: (count) => text$1("exportCount", count),
+				onRun: (rows) => exportFlow.open(rows)
+			}] : [],
+			...named.bulkActions,
+			...can(permissions, "delete") ? [{
+				label: (count) => text$1("deleteCount", count),
+				destructive: true,
+				onRun: (rows) => remove.startBulk(rows.map(target))
+			}] : []
+		],
 		rowNumbers: false,
 		pinKey: auth.kind === "signed-in" ? pinnedStorageKey(auth.user.id, navItemId(resource, address.list)) : void 0,
 		scroll: "parent",
@@ -477,6 +488,7 @@ const LoadedList = ({ model, address, scope, heading }) => {
 		children: [
 			remove.dialogs,
 			exportFlow.dialogs,
+			named.prompt,
 			/* @__PURE__ */ jsx(PageHeader, {
 				title: heading?.title ?? plural,
 				subtitle: heading ? heading.subtitle : view?.help,

package/dist/app/named-icon.js

@@ -1,4 +1,4 @@
-import { Ban, Bath, Bed, Bell, Bookmark, Calendar, DoorOpen, ExternalLink, FileText, Heart, House, KeyRound, LandPlot, Leaf, RulerDimensionLine, Send, Tag, Wallet } from "lucide-react";
+import { Archive, ArrowRightLeft, Ban, Bath, Bed, Bell, Bookmark, Calendar, Camera, Copy, Cpu, DoorOpen, Download, ExternalLink, FileText, HardDrive, Heart, House, KeyRound, LandPlot, Leaf, MemoryStick, Network, Play, Plug, Power, RotateCw, RulerDimensionLine, Send, Server, Square, Tag, Terminal, Upload, Wallet, Wrench } from "lucide-react";
 //#region src/app/named-icon.ts
 /** The icons an action's, a field's or a sign-in prompt's `icon` may name. */
 const byName = {
@@ -19,7 +19,25 @@ const byName = {
 	bell: Bell,
 	bookmark: Bookmark,
 	"external-link": ExternalLink,
-	ban: Ban
+	ban: Ban,
+	play: Play,
+	stop: Square,
+	power: Power,
+	restart: RotateCw,
+	terminal: Terminal,
+	camera: Camera,
+	"hard-drive": HardDrive,
+	server: Server,
+	network: Network,
+	archive: Archive,
+	copy: Copy,
+	"arrow-right-left": ArrowRightLeft,
+	download: Download,
+	upload: Upload,
+	cpu: Cpu,
+	memory: MemoryStick,
+	plug: Plug,
+	wrench: Wrench
 };
 /** The icon a name stands for, or nothing for a name the app does not know. */
 const namedIcon = (name) => name !== void 0 && Object.hasOwn(byName, name) ? byName[name] : void 0;

package/dist/app/pages/action-href.js

@@ -1,3 +1,4 @@
+import { actionApplies } from "./action-when.js";
 import { hrefField } from "@protobase/schema/internal";
 //#region src/app/pages/action-href.ts
 /** `href` with every `{field}` replaced by the record's value, percent-encoded; a missing value becomes empty. */
@@ -27,10 +28,12 @@ const openLink = (target) => {
 const hostOf = (target) => URL.canParse(target) ? new URL(target).hostname.replace(/^www\./, "") : "";
 const holdsAll = (record, values) => Object.entries(values).every(([name, value]) => Object.is(record[name], value));
 /**
-* `action` as it shows for `record`: an update that would change nothing there, and a link whose `href` has no target
-* there, are left out, and `{host}` in a link's label becomes the host its target opens, without `www.`.
+* `action` as it shows for `record`: one whose `when` does not hold there is left out, or shown as it is when it
+* disables instead; an update that would change nothing there, and a link whose `href` has no target there, are left
+* out, and `{host}` in a link's label becomes the host its target opens, without `www.`.
 */
 const actionFor = (action, record) => {
+	if (!actionApplies(action, record)) return action.otherwise === "disable" ? action : void 0;
 	const run = action.run;
 	if (run?.kind === "update") return record && !action.inputs?.length && holdsAll(record, run.values) ? void 0 : action;
 	if (run?.kind !== "link" || !("href" in run)) return action;

package/dist/app/pages/action-prompt.js

@@ -2,6 +2,8 @@ import { ActionInputsDialog } from "./action-inputs/action-inputs-dialog.js";
 import { ConfirmAction } from "./confirm-action.js";
 import { jsx } from "react/jsx-runtime";
 //#region src/app/pages/action-prompt.tsx
+/** Whether the action is drawn in red, as one that destroys or interrupts something: a delete, or one with `variant: 'danger'`. */
+const isDanger = (action) => action.variant === "danger" || action.run?.kind === "delete";
 /** Whether pressing the action's button opens a dialog first: to ask its question, or for its inputs. */
 const asksFirst = (action) => Boolean(action.confirm || action.inputs?.length);
 /** The dialog an action that asks first opens: its inputs, or else its question. */
@@ -26,4 +28,4 @@ const ActionPrompt = ({ action, label, danger, onCancel, onConfirm, onSubmit })
 	});
 };
 //#endregion
-export { ActionPrompt, asksFirst };
+export { ActionPrompt, asksFirst, isDanger };

package/dist/app/pages/action-when.js

@@ -0,0 +1,14 @@
+import { evaluateCondition, parseCondition } from "@protobase/layout";
+//#region src/app/pages/action-when.ts
+/**
+* Whether `action` applies to `record`: always without a `when`, else when its condition holds for the record's own
+* fields. With a `when` there is nothing to apply to without a record, and a condition that does not parse never holds.
+*/
+const actionApplies = (action, record) => {
+	if (action.when === void 0) return true;
+	if (!record) return false;
+	const condition = parseCondition(action.when);
+	return condition.ok && evaluateCondition(condition, record);
+};
+//#endregion
+export { actionApplies };

package/dist/app/pages/blocks/action.js

@@ -8,7 +8,8 @@ import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 //#region src/app/pages/blocks/action.tsx
 /**
 * A button for a named action of `resource`'s view, by default of the record around it, on that record, asking first
-* when the action has `confirm` or `inputs`; nothing when the view has no such action for the user.
+* when the action has `confirm` or `inputs`; nothing when the view has no such action for the user, or none for the
+* record. It is drawn as the action's `variant` unless the block names its own.
 */
 const ActionButton = ({ name, resource, label, variant }) => {
 	const scope = useLayoutRecord();
@@ -16,10 +17,11 @@ const ActionButton = ({ name, resource, label, variant }) => {
 	const [asking, setAsking] = useState(false);
 	if (!action.action) return null;
 	const text = label ?? action.action.label;
+	const shown = variant ?? action.action.variant ?? "secondary";
 	const start = () => asksFirst(action.action) ? setAsking(true) : void action.run();
 	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Button, {
 		size: "sm",
-		variant: variant ?? "secondary",
+		variant: shown,
 		loading: action.running,
 		disabled: Boolean(action.blocked),
 		title: action.blocked,
@@ -28,7 +30,7 @@ const ActionButton = ({ name, resource, label, variant }) => {
 	}), asking && /* @__PURE__ */ jsx(ActionPrompt, {
 		action: action.action,
 		label: text,
-		danger: variant === "danger",
+		danger: shown === "danger",
 		onCancel: () => setAsking(false),
 		onConfirm: () => {
 			setAsking(false);

package/dist/app/pages/messages.js

@@ -12,9 +12,15 @@ const text = defineMessages({
 		needsRecord: "Needs a record",
 		cannotChange: "You cannot change this record",
 		cannotDelete: "You cannot delete this record",
+		doesNotApply: "Does not apply to this record",
 		noHandler: (name) => `The app has no handler for "${name}"`,
 		noInputComponent: (component, input) => `The app has no component "${component}" for input "${input}"`,
 		done: (label) => `${label}: done`,
+		doneOn: (label, done, skipped, failed) => [
+			`${label}: done on ${done}`,
+			...skipped > 0 ? [`skipped ${skipped} it does not apply to`] : [],
+			...failed > 0 ? [`failed on ${failed}`] : []
+		].join(", "),
 		failed: (label) => `${label} failed`,
 		noAction: (name) => `No action "${name}"`,
 		couldNotLoad: "Could not load",
@@ -41,9 +47,15 @@ const text = defineMessages({
 		needsRecord: "Vraagt een record",
 		cannotChange: "Je kunt dit record niet wijzigen",
 		cannotDelete: "Je kunt dit record niet verwijderen",
+		doesNotApply: "Geldt niet voor dit record",
 		noHandler: (name) => `De app heeft geen handler voor "${name}"`,
 		noInputComponent: (component, input) => `De app heeft geen component "${component}" voor invoer "${input}"`,
 		done: (label) => `${label}: klaar`,
+		doneOn: (label, done, skipped, failed) => [
+			`${label}: klaar voor ${done}`,
+			...skipped > 0 ? [`${skipped} overgeslagen waarvoor het niet geldt`] : [],
+			...failed > 0 ? [`mislukt voor ${failed}`] : []
+		].join(", "),
 		failed: (label) => `${label} mislukt`,
 		noAction: (name) => `Geen actie "${name}"`,
 		couldNotLoad: "Kon niet laden",

package/dist/app/pages/record-actions.js

@@ -3,7 +3,7 @@ import "../../app-shell/top-bar.js";
 import { ActionRail } from "../../record-view/action-rail.js";
 import { AppLink, useAppAddress } from "../use-app-address.js";
 import { ActionMenu } from "../../record-view/action-menu.js";
-import { ActionPrompt, asksFirst } from "./action-prompt.js";
+import { ActionPrompt, asksFirst, isDanger } from "./action-prompt.js";
 import { useActionRunner } from "./use-run-action.js";
 import { text } from "../record-messages.js";
 import { actionIcon } from "../action-icon.js";
@@ -14,7 +14,7 @@ import { createPortal } from "react-dom";
 //#region src/app/pages/record-actions.tsx
 /**
 * The record page's actions in one rail: Edit, a link to the form at `edit`, when the page offers it; the view's named
-* actions, run like the Action block runs them, a delete among them returning to the list; and the record's own Delete,
+* actions, run like the Action block runs them, a delete among them returning to the list, a delete and a danger one in red; and the record's own Delete,
 * `onDelete`, unless a named action deletes already. On a mobile screen they sit in the top bar's menu instead, at hand
 * however long the record is, when the shell has a top bar.
 */
@@ -38,7 +38,7 @@ const RecordActions = ({ model, stored, recordKey, edit, onDelete }) => {
 		icon: actionIcon(action.icon),
 		blocked: runner.blocked(action),
 		running: runner.running === action.name,
-		...action.run?.kind === "delete" && { tone: "danger" },
+		...isDanger(action) && { tone: "danger" },
 		onRun: () => asksFirst(action) ? setAsking(action) : void runner.run(action)
 	}));
 	const deletes = runner.actions.some((action) => action.run?.kind === "delete");
@@ -75,7 +75,7 @@ const RecordActions = ({ model, stored, recordKey, edit, onDelete }) => {
 		asking && /* @__PURE__ */ jsx(ActionPrompt, {
 			action: asking,
 			label: asking.label,
-			danger: asking.run?.kind === "delete",
+			danger: isDanger(asking),
 			onCancel: () => setAsking(void 0),
 			onConfirm: () => {
 				setAsking(void 0);

package/dist/app/pages/run-each.js

@@ -0,0 +1,24 @@
+//#region src/app/pages/run-each.ts
+/**
+* Runs `run` on each of `records` that `applies` to, one after another, so a failure on one leaves the others to run:
+* it is counted, and the first is kept for the caller to show.
+*/
+const runEach = async (records, applies, run) => {
+	const applying = records.filter(applies);
+	const outcome = {
+		done: 0,
+		skipped: records.length - applying.length,
+		failed: 0
+	};
+	for (const record of applying) {
+		const failure = await run(record).then(() => void 0, (error) => ({ error }));
+		if (!failure) outcome.done += 1;
+		else {
+			outcome.failed += 1;
+			if (outcome.failed === 1) outcome.error = failure.error;
+		}
+	}
+	return outcome;
+};
+//#endregion
+export { runEach };

package/dist/app/pages/use-run-action.js

@@ -5,7 +5,9 @@ import { useAdminMeta, usePermissions } from "../meta-gate.js";
 import { useAppAddress } from "../use-app-address.js";
 import { useProjectUi } from "./project-ui.js";
 import { can } from "../permissions.js";
+import { actionApplies } from "./action-when.js";
 import { actionFor, linkTarget, openLink } from "./action-href.js";
+import { runEach } from "./run-each.js";
 import { useRefreshResource } from "./use-layout-data.js";
 import { useState } from "react";
 import { fillAddress, updateValues } from "@protobase/schema/internal";
@@ -14,9 +16,11 @@ const message = (error) => error instanceof Error ? error.message : text("someth
 /**
 * The named actions of `resource`'s view, ready to run on `scope` (the record they act on): built-in behaviour first
 * (`update`, `delete`, `link`, and `ai`, which the server runs), else the handler the project registered under the
-* action's name. An update whose values the record holds already is left out, and so is a link to a URL the record
-* holds while it holds none. `blocked` says why one cannot run; `afterRun` hears about every action that succeeded.
+* action's name. One whose `when` does not hold for the record is left out, or blocked with its `reason`; an update
+* whose values the record holds already is left out, and so is a link to a URL the record holds while it holds none.
+* `blocked` says why one cannot run; `afterRun` hears about every action that succeeded.
 * `submit` runs one with the answers to its inputs (a handler gets them, an update writes them) and throws its failure, for the dialog to show.
+* `runEach` runs one on each of several records it applies to, as a list's selection does, and says how that went.
 */
 const useActionRunner = (resource, scope, afterRun) => {
 	const { views } = useAdminMeta();
@@ -29,35 +33,41 @@ const useActionRunner = (resource, scope, afterRun) => {
 	const { go } = useAppAddress();
 	const [running, setRunning] = useState();
 	const actions = (views[resource]?.actions ?? []).flatMap((action) => actionFor(action, scope?.record) ?? []);
-	const blocked = (action) => {
+	const blockedOn = (action, on) => {
 		const kind = action.run?.kind;
-		if ((kind === "update" || kind === "delete" || kind === "ai") && !scope) return text("needsRecord");
-		if ((kind === "update" || kind === "ai") && (!can(permissions, "update") || scope?.permissions?.update === false)) return text("cannotChange");
-		if (action.run?.kind === "ai" && scope?.permissions?.fields?.[action.run.writes] === "read") return text("cannotChange");
-		if (kind === "delete" && (!can(permissions, "delete") || scope?.permissions?.delete === false)) return text("cannotDelete");
+		if ((kind === "update" || kind === "delete" || kind === "ai") && !on) return text("needsRecord");
+		if (!actionApplies(action, on?.record)) return action.reason ?? text("doesNotApply");
+		if ((kind === "update" || kind === "ai") && (!can(permissions, "update") || on?.permissions?.update === false)) return text("cannotChange");
+		if (action.run?.kind === "ai" && on?.permissions?.fields?.[action.run.writes] === "read") return text("cannotChange");
+		if (kind === "delete" && (!can(permissions, "delete") || on?.permissions?.delete === false)) return text("cannotDelete");
 		if (!action.run && !handlers?.[action.name]) return text("noHandler", action.name);
 		const custom = action.inputs?.find((input) => input.kind === "custom" && !components?.[input.component ?? ""]);
 		if (custom) return text("noInputComponent", String(custom.component), custom.name);
 	};
-	const perform = async (action, values) => {
+	const blocked = (action) => blockedOn(action, scope);
+	const execute = async (action, on, values) => {
 		const { run } = action;
 		if (run?.kind === "link") {
-			if ("to" in run) go(fillAddress(run.to, scope?.record));
-			else openLink(linkTarget(run.href, scope?.record));
+			if ("to" in run) go(fillAddress(run.to, on?.record));
+			else openLink(linkTarget(run.href, on?.record));
 			return;
 		}
-		if (run?.kind === "update") await client.update(resource, scope.key, updateValues(run.values, values ?? {}), scope.etag ?? "*");
-		else if (run?.kind === "delete") await client.remove(resource, scope.key, { etag: scope.etag });
-		else if (run?.kind === "ai") await client.generate(resource, scope.key, action.name);
+		if (run?.kind === "update") await client.update(resource, on.key, updateValues(run.values, values ?? {}), on.etag ?? "*");
+		else if (run?.kind === "delete") await client.remove(resource, on.key, { etag: on.etag });
+		else if (run?.kind === "ai") await client.generate(resource, on.key, action.name);
 		else await handlers[action.name]({
 			resource,
-			record: scope?.record,
-			recordKey: scope?.key,
-			etag: scope?.etag,
+			record: on?.record,
+			recordKey: on?.key,
+			etag: on?.etag,
 			client: handlerClient,
 			navigate: go,
 			...values && { values }
 		});
+	};
+	const perform = async (action, on, values) => {
+		await execute(action, on, values);
+		if (action.run?.kind === "link") return;
 		await refresh(resource);
 		toast.show({
 			state: "success",
@@ -65,10 +75,10 @@ const useActionRunner = (resource, scope, afterRun) => {
 		});
 		afterRun?.(action);
 	};
-	const run = async (action) => {
-		if (blocked(action)) return;
+	const run = async (action, on = scope) => {
+		if (blockedOn(action, on)) return;
 		setRunning(action.name);
-		await perform(action).catch((error) => toast.show({
+		await perform(action, on).catch((error) => toast.show({
 			state: "error",
 			title: text("failed", action.label),
 			description: message(error)
@@ -78,14 +88,35 @@ const useActionRunner = (resource, scope, afterRun) => {
 	const submit = async (action, values) => {
 		if (blocked(action)) return;
 		setRunning(action.name);
-		await perform(action, values).finally(() => setRunning(void 0));
+		await perform(action, scope, values).finally(() => setRunning(void 0));
+	};
+	/** Whether `action` shows and can run on `on`. */
+	const appliesOn = (action, on) => actionFor(action, on.record) !== void 0 && !blockedOn(action, on);
+	const runOnEach = async (action, records, skipped = 0) => {
+		setRunning(action.name);
+		const outcome = await runEach(records, (on) => appliesOn(action, on), (on) => execute(action, on));
+		setRunning(void 0);
+		await refresh(resource);
+		const title = text("doneOn", action.label, outcome.done, outcome.skipped + skipped, outcome.failed);
+		toast.show(outcome.failed > 0 ? {
+			state: "error",
+			title,
+			description: message(outcome.error)
+		} : {
+			state: "success",
+			title
+		});
+		if (outcome.done > 0) afterRun?.(action);
 	};
 	return {
 		actions,
 		blocked,
+		blockedOn,
+		appliesOn,
 		running,
 		run,
-		submit
+		submit,
+		runEach: runOnEach
 	};
 };
 /** One named action of `resource`'s view, for a button. */

package/dist/data-grid/bulk-actions.js

@@ -0,0 +1,12 @@
+//#region src/data-grid/bulk-actions.ts
+/** The actions offered for `selected`, each with the rows it runs on and how many it skips. */
+const offeredBulkActions = (actions, selected) => actions.flatMap((action) => {
+	const rows = action.available ? selected.filter(action.available) : selected;
+	return rows.length === 0 ? [] : [{
+		action,
+		rows,
+		skipped: selected.length - rows.length
+	}];
+});
+//#endregion
+export { offeredBulkActions };

package/dist/data-grid/data-grid.js

@@ -2,6 +2,7 @@ import { cn } from "../lib/cn.js";
 import { useIsDesktop } from "../lib/use-media-query.js";
 import { RouteLink } from "../primitives/route-link.js";
 import { buildColumns, features } from "./columns.js";
+import { offeredBulkActions } from "./bulk-actions.js";
 import { GridFooter } from "./grid-footer.js";
 import { RowMenu, availableActions } from "./row-menu.js";
 import { desktopMinScale, gridMinWidth, gutterWidthFor } from "./grid-template.js";
@@ -260,11 +261,11 @@ const DataGrid = ({ columns: given, source, naturalSort, initialScrollIndex = 0,
 			total,
 			className: own ? void 0 : "sticky bottom-[var(--pb-sticky-bottom,0px)] z-20",
 			selectedCount,
-			bulkActions: bulkActions?.map((action) => ({
-				label: action.label(selectedCount),
+			bulkActions: offeredBulkActions(bulkActions ?? [], Object.keys(rowSelection).flatMap((id) => selectedRows.current.get(id) ?? [])).map(({ action, rows, skipped }) => ({
+				label: action.label(rows.length),
 				destructive: action.destructive,
 				onRun: () => {
-					action.onRun(Object.keys(rowSelection).flatMap((id) => selectedRows.current.get(id) ?? []));
+					action.onRun(rows, skipped);
 					setRowSelection({});
 					selectedRows.current.clear();
 				}

package/dist/data-grid/row-menu.js

@@ -6,6 +6,7 @@ import { MoreHorizontal } from "lucide-react";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { createPortal } from "react-dom";
 //#region src/data-grid/row-menu.tsx
+const labelOf = (action, row) => typeof action.label === "string" ? action.label : action.label(row);
 /** The actions that apply to a row; a row with none gets no menu at all. */
 const availableActions = (actions, row) => actions.filter((action) => action.available?.(row) ?? true);
 /**
@@ -33,25 +34,32 @@ const RowMenu = ({ row, actions }) => {
 			onClick: (event) => event.stopPropagation(),
 			style: place ?? { visibility: "hidden" },
 			className: "fixed z-50 min-w-36 rounded-md border bg-background py-1 shadow-pop",
-			children: actions.map((action) => /* @__PURE__ */ jsx("li", {
-				role: "none",
-				children: action.link ? /* @__PURE__ */ jsx(RouteLink, {
-					role: "menuitem",
-					to: action.link(row),
-					onClick: () => setOpen(false),
-					className: cn("block w-full px-3 py-1.5 text-left hover:bg-muted", action.destructive && "text-danger-text"),
-					children: action.label
-				}) : /* @__PURE__ */ jsx("button", {
-					type: "button",
-					role: "menuitem",
-					className: cn("block w-full px-3 py-1.5 text-left hover:bg-muted", action.destructive && "text-danger-text"),
-					onClick: () => {
-						setOpen(false);
-						action.onSelect(row);
-					},
-					children: action.label
-				})
-			}, action.label))
+			children: actions.map((action, index) => {
+				const label = labelOf(action, row);
+				const blocked = action.blocked?.(row);
+				const itemClass = cn("block w-full px-3 py-1.5 text-left hover:bg-muted disabled:cursor-default disabled:opacity-60 disabled:hover:bg-transparent", action.destructive && "text-danger-text");
+				return /* @__PURE__ */ jsx("li", {
+					role: "none",
+					children: action.link ? /* @__PURE__ */ jsx(RouteLink, {
+						role: "menuitem",
+						to: action.link(row),
+						onClick: () => setOpen(false),
+						className: itemClass,
+						children: label
+					}) : /* @__PURE__ */ jsx("button", {
+						type: "button",
+						role: "menuitem",
+						disabled: blocked !== void 0,
+						title: blocked,
+						className: itemClass,
+						onClick: () => {
+							setOpen(false);
+							action.onSelect(row);
+						},
+						children: label
+					})
+				}, index);
+			})
 		}), document.body)]
 	});
 };