Bulk item edit

A React block (a whole screen) in Beamline's Inventory app.

Many items corrected at once. Pick a folder, with its subfolders or not (fixed once anything is edited), up to a limit said. The items in a grid: name, SKU, folder, quantity, unit, minimum, price and notes, the editable ones typed in place; an edited cell is tinted with what it was beside it struck. A blank cell changes nothing; clearing a value is its own act on the rows picked. A quantity typed sets the count, not a change to it. A row whose edits don't hold (an empty name, a count that isn't a whole number, a price below zero) is said in its Check column and will be skipped while the others apply; the changes and the skips are counted. Undo steps back through edits until they're sent. Review lists each change old → new and the rows skipped; Update sends them once with each row's revision; each row then says applied, skipped, or changed or deleted by someone else meanwhile and left alone; an answer that never comes back is said and the same update sends again without applying twice; applied updates can't be undone.

Use it for

Correcting many records at once after a recount, a price change or an import, where bad rows are skipped and the rest apply.
Where blank must mean unchanged, clearing must be explicit and concurrent edits must not be overwritten.

Not for

Finding and picking items (inventory-finder).
Importing a file (import-mapping).

Anatomy

header: the tool's mark, title, folder, subfolders, how many items
toolbar: changes, will be skipped, Undo, Review; with rows picked: the field to clear and Clear on picked; after: applied, skipped, changed meanwhile
grid: the items with edited cells (the unit beside the quantity), a Check column, Folder only when the scope spans folders
review: each change old → new, skipped rows, the outcome, Back to editing, Update

States

nothing edited, edited, invalid rows, cleared values, over the limit
reviewing, sending, refused, answer lost, done with applied, skipped and changed meanwhile
phone: one column, the grid scrolls sideways
right to left: mirrored
reduced motion: through the tokens

Keyboard

The grid's own keys: arrows move, Enter or typing edits, Enter commits, Escape cancels; Tab through the toolbar and the review

Motion

Nothing runs at rest.

Props

Prop	Type	Default	Description
`folders` (required)	`{ id: string; path: string; parentId: string \| null; }[]`	—
`items` (required)	`BulkItem[]`	—
`defaultFolder`	`string`	—	The folder edited at first.
`defaultPatches`	`Record<string, Partial<Record<BulkField, string \| number \| null>>>`	—	Edits already made at first (a session reopened mid-way).
`currency` (required)	`string`	—
`limit`	`number`	—	Items allowed in one edit.
`onCommit` (required)	`(request: { key: string; rows: { id: string; revision: number; patch: Partial<Record<Bu…`	—	Sends every valid row's patch once, each with the revision it was read at.
`product`	`string`	—
`className`	`string`	—	Classes on the documented visual root; no override by default.
`style`	`CSSProperties`	—	Inline styles on the documented visual root; no overrides by default.
`ref`	`Ref<HTMLDivElement>`	—	Receives the documented native target or imperative handle; omitted by default.

Built from

Dependencies

lucide-react

Import

import { BulkItemEdit } from "@beamline/bulk-item-edit";

Get it

Bulk item edit is part of Beamline UI. Install the parts you need in your React app as compiled packages or editable source. Get Beamline · Connect your agent

Bulk item editComplete system · $49

Many items corrected at once.

Correcting an aisle after a recount

Aisle B has been recounted. Edited cells show what they were. A note has been cleared on purpose, because a blank cell would leave it as it is. The smoke alarms were typed as 2.5, so that row will be skipped and the rest will apply. Review lists every change. After Update, the bottle trap is left alone because someone else changed it meanwhile.

0 × 0full

States

The main store with nothing edited yet; an update whose answer is lost, sent again without applying twice.