@openseat/editor

Right-hand properties panel. Every value comes from the store on each render, so undo, redo and canvas edits show at once.

• Nothing selected: layout settings, venue, defaults and categories.
• One object: the panel for its type plus placement.
• Several seats (seat mode, "Edit seats"): bulk seat editing.
• Several rows: row tools plus the multi-selection tools.
• Anything else: multi-selection tools.

Floating panel listing the layout's issues grouped by kind. Clicking an entry selects its object (entering its section or row) and zooms to it; common problems have one-click fixes. Render it inside .os-canvas.

Layer tree: sections, their rows / tables / GA areas, and their seats. Rows show plain-language names ("Rectangle 1", "Standing area General"). Click selects (entering the section or row it lives in), Shift-click selects the range from the last clicked row, Ctrl/Cmd-click toggles, double-click (or F2) renames (a row's or seat's label, other objects' layer name). Eye and lock buttons set the flag on that object only; children hidden or locked through a parent are greyed (is-inherited-hidden / is-inherited-locked) and keep their own flags. Large trees are windowed.

The visual layout designer: tool palette, canvas, inspector and layers, with undo/redo, import/export, presets, a buyer preview and saving. All edits go through the editor store, so every change is one undoable step. The canvas behaviour lives in useCanvasInteractions; this component composes the chrome around it.

The buyer's view of the layout being edited: the booking map with overview-to-section zoom, the legend (with prices when the host supplies them) and the selection summary; everything is available except what is marked not for sale. A layout with sections opens on the section overview, seats hidden until a section is chosen, as buyers see it. Seat selections are local to the preview and discarded when it closes; the layout is never changed.

Asks before a save that removes seats, in plain language: the seats by name (never IDs) and, when the host's isInventoryInUse told the store, how many of them have tickets. Shown while the store holds a pending save diff; Cancel has the focus, and "Save and remove" saves once.

Where the user is editing, as a breadcrumb ("Layout › Section 101 › Row C") with a "Back to whole map" button and an Exit button (one level up). Clicking an earlier crumb leaves the scopes after it. In seat mode (the Select seats tool) at the top level it shows only "Selecting single seats" and the back button. With nothing entered and one section selected, a hint says how to edit its seats.

Subscribes to part of the editor state. Select plain fields (not new objects or arrays built in the selector), so components re-render only when that field changes.

The current layout's issues. Computed immediately on mount, then again 150 ms after the layout stops changing.

Replaces fields of the newest entry (no-op on an empty history).

"84 seats", "1,200 places", "60 seats · 300 places", "10 booths"; "0 seats" when nothing uses it. What is held back follows: "33 booths · 3 held back", or "304 seats held back" when nothing of the type is for sale.

An arc (wedge) section from three clicks: the arc center (stage or field centre), first on the front row at the start angle, and second at the end angle, whose distance from the centre sets the back row. The sweep runs clockwise on screen from first to second (at most 360°). Null when the clicks do not describe a usable arc.

Opens a gesture group: until endGroup, every recorded entry folds into one undo step, however long the gesture takes. Opening a group with another key closes the open one first; the same key keeps it open.

Centre of a bounds box.

Message for clipboard text over MAX_CLIPBOARD_BYTES, or null when it is small enough.

Row labels in front-to-back order: A, B … Z, AA, AB (shorter first), numbers by value.

World bounds of the content: every visible object. Null for an empty layout.

Creates the editor's state store. Framework-independent (Zustand vanilla); the React components subscribe to it, and hosts can too.

Default objects created by a placement tool at point. IDs are unique in layout. Returns null for tools that collect more input (rows, polygon), select (select, selectSeats, pan, paint), or change the document some other way (focal: the UI calls setFocalPoint).

What a set of objects is, in user terms: one object by name ("Table T3"), otherwise counts by kind in document order ("400 seats", "2 tables and 1 booth"). "nothing" for an empty list.

Caption size for a new floor divider: a fiftieth of the venue's longer side (120 on a 6,000-unit ground, about 15 px at the 12% that shows it whole), or null on a layout under 1,000 units, where the theme's own size reads well.

A new floor divider (open path with a caption, not yet added) through points (at least 2).

The stage, rectangle or booth a drag-to-size tool (isDragSizeTool) creates for a drag over rect: centred on the drag and exactly as large, but at least 10 x 10 (a shorter drag gives the minimum size). Corners snap to the grid when state.snapToGrid is set. Uses the same default names and IDs as a click. Null for other tools.

A block of rows from a rectangle drag (the Rows tool in block mode). The rectangle runs from the snapped start to end: one seat per seatSpacing across (rounded, at least one) and one row per rowSpacing down. Row 0 (the front row, labelled first) is on the start's side, or, when the layout has a focal point, on the side nearer the focal point; seats are numbered from the start's side, whichever way the drag goes.

Without intoSectionId the result is a new parametric block section with an auto outline, centred on the block. With it, the rows are plain parametric rows of that section, labelled after its existing rows.

Rows drawn with the pointer: the first row runs from start towards end, with as many seats as fit at seatSpacing. Further rows stack on whichever side of it side lies. Seats are numbered from the start of the drag and rows are labelled A, B, C… (or from firstRowLabel) away from the first row.

Every row is parametric: its rotation is the drawn angle and its layout (spacing, start anchor, radius, tangent seat rotation, labeling) reproduces the seats exactly, so later edits regenerate the row in place.

True for the object types whose own fields already draw their name on the map (a booth's or table's label).

Closes the open gesture group (no-op without one).

A new note (footnote label, not yet added) made by core createFootnote: centred under the content, NOTE_GAP below its bottom edge (the canvas centre for an empty layout), with text (default DEFAULT_NOTE_TEXT, a prompt to type over).

Seats, places and booths of a type held back from sale.

True when focus is on something Enter, Space or the arrow keys activate or move within: buttons, links, checkboxes and radios, and menu items, options, tabs and the like (by ARIA role). The editor must leave those keys to the element there.

Tools whose primary gesture is a press-drag-release on the canvas (rather than clicks): rows in either mode, and rectangle sections and GA areas. Arc sections are built from clicks.

Tools that size what they place to a press-drag-release (a click places the default size).

True for a path drawn as a floor divider: one with a caption.

Tools that create something where you click.

Tools that stay active after placing, so you can place several in a row (15 tables, 20 booths) without picking the tool again. Escape or another tool ends them. Only the stage-centre (focal) tool is one-shot.

True for the object types that can be marked Not for sale (seats, rows, sections, tables, booths, zones).

True when keyboard focus is in a text field (a text-like INPUT, a TEXTAREA, a SELECT or contentEditable), where shortcuts must not fire. Checkboxes, sliders, colour pickers and buttons are not typing targets.

True for a layout nobody has named yet ("", "Untitled layout").

ID of the text label that shows an object's name on the map ("Show name on map").

Ticket types that are never sold (metadata.openseat.unsellableCategories) that exist in the layout.

The never-sold ticket types that hold back ids (sections, rows, tables, seats, zones, booths, by their own or their seats' type), with how many seats or places each holds back. Empty when nothing selected is held back by its ticket type.

A new stage labelled "Stage", with no style of its own, so the theme's stage look (soft grey, thin border, letter-spaced title) applies, and the chosen outline shape ("rect" leaves shape out).

The colour for the next ticket type of layout: the first palette colour no category uses yet (compared case-insensitively). When all twelve are taken the palette repeats, by category count.

"Zone 1", "Zone 2": the smallest ordinal no zone (GA area) or section label uses yet, so a new zone never repeats a name buyers see.

Whether the objects ids are Not for sale: each sellable object counts as not for sale when it, or the row, table or section it belongs to, is on the layout's Not for sale list (a booth also when it stands inside a listed section). Objects that sell nothing (shapes, stages, labels) are ignored; with none left the answer is "none".

Any object as a person names it: "Section Stalls", "Row C", "Table T3", "Booth B7", "Zone General", "Floor divider GROUND FLOOR", "Rectangle 1", or a seat's seatLabel. "item" for a missing object.

True when the arrow keys belong to the focused element: radios, sliders, menu items, options, tabs, tree items, and anything inside a menu, tree, tab list, radio group or list box. Plain buttons, links and checkboxes have no arrow-key action, so the editor may nudge with arrows while they have focus.

The zone that has ticket type categoryId to itself: the one standing area or zone section ("Sections only") with that type, when nothing else (no seats elsewhere, no booth, no other area) has it. Its name and the type's name are then two names for one thing ("General standing" and "Silver"), so renaming one offers to rename the other. Null otherwise.

The paint tool's seat for a click at point on container (a section, row or table): the nearest drawn seat inside it, within a few seat sizes of the point. "far" when the click is well away from every seat (the section's title, an empty corner); null when the container has no seats to pick from (a zone section, whose seats are hidden, or an empty section), so the caller paints the container itself.

The seats a paint click at point would change at level ("row": the whole row of the nearest seat, "seat": that seat, "section": every seat of its section), or null when no seat is near. The paint tool previews these under the pointer, and a click paints exactly them (the store's assignCategory picks the same nearest seat).

Parses clipboard text made by serializeClipboard. Returns null for anything else: text over MAX_CLIPBOARD_BYTES, more than MAX_PASTE_OBJECTS objects, text that is not JSON, a missing marker, a wrong format or version, an empty or missing object list, or any object (or category) that fails the layout schema. Bounds are recomputed when absent or malformed. Use readClipboardText for the reason.

Turns the developer messages core throws ("updateSectionSeating needs valid seating: rows: A section may generate at most 20000 seats; this block has 766000") into sentences an organiser can act on ("That is too many seats for one section: 7,66,000. One section can hold up to 20,000 seats."). Messages that are already plain pass through unchanged.

Builds a polygon, section (custom outline) or zone (GA area) from points clicked in layout space. The origin is placed at the points' centre (a zone's at their centroid). Null for fewer than three points.

The number in a price as typed or shown ("₹1,499" → 1499), or null.

Label text size that reads at about 16 screen pixels at zoom scale: 16 at 100% or more, 130 at 12%.

Parses clipboard text made by serializeClipboard, checking the size limits first: text over MAX_CLIPBOARD_BYTES and payloads of more than MAX_PASTE_OBJECTS objects are rejected with an error message before any object is validated. Other text (not ours, malformed) gives a null payload without an error.

Adds an entry, clearing redo. Merges into the previous entry when the keys match and the new entry is within the merge window of the previous entry's first change (the window does not slide), and, with requireContinuity, when the new entry starts where the previous one ended.

While a gesture group is open (beginGroup), every entry after the group's first merges into the previous one regardless of keys and the window (continuity is still required when asked for).

A rectangle section, zone (GA area) or rectangle shape spanning a drag from start to end. Both corners snap to opts.grid (0 disables snapping). Null when the result is smaller than 10 x 10, so a stray click creates nothing. A zone takes the shape (rectangle, rounded or trapezoid), seating and price tier of opts.zone; without it, the editor store applies the Zone tool's settings when the zone is added.

Removes a ticket type that is in use: what had it gets to (another ticket type) or none. The never-sold list drops it too.

The layout with ticket type categoryId called typeName and area zoneId called zoneName.

Maps a key press to an editor command. mac selects Cmd rather than Ctrl as the command modifier. Returns null for keys the editor does not handle, so they reach the browser and host app untouched. Enter finishes the current shape while ctx.drafting, and otherwise enters the selection's scope.

Price × (seats + places + booths) for every sellable ticket type, so booth and stall income counts like seat income. Never-sold types count nothing, and neither do seats, places and booths marked Not for sale (counted in heldBack).

The rows of sectionIds whose labels lie from from to to (inclusive, either order).

"Rows A–D", "Row C": the range as organisers say it.

True when two documents have the same content. Layout operations reuse unchanged objects, so only objects that differ by reference are compared by value: cheap for the few objects an inspector edit touches.

Sellable ticket types with the same price (by amount, so "250" and "₹250" match) that are both on the map. Free types (price 0) are left out: a free Guests type next to a free Press type is on purpose.

What the save removes, in plain words and without IDs: "Row C, Seat 5 (Stalls) and 3 more will be removed. 2 of them have tickets sold or held; those buyers will need new seats."

A seat as a person names it: "Row A, Seat 10", or "Table T3, Seat 2". When another seat in the layout has the same name, its section follows: "Row A, Seat 10 (Stalls)".

The visible seat nearest point (layout space), when it lies within three seat sizes of it; seats of zone sections (not drawn) are skipped. This is the seat a paint click at point means, whichever row's or section's outline the click landed on: with curved rows, the outline of the row above can cover the middle of the row the organiser sees under the pointer.

The seats from anchorId to id inclusive, in the slot order of the row (or table) that holds both, for Shift-click range selection. The result runs from the anchor towards id. Empty when either is not a seat or the two are not in the same row or table.

What a seat-tool click at point does. A click near the extrapolated next slot past either end of a row (rows with at least two seats; within tolerance, default 1.5 x the row's seat pitch, and nearer that slot than the row's end seat) extends that row; otherwise a single seat is created at the (grid-snapped) point. Locked and hidden rows are never extended.

The row labels of the given sections, each once, in compareRowLabels order ("A" … "J"), for picking "rows A to D".

The selectable units of the current scope, in document order, without effectively locked or hidden objects:

• inside a row or table (scopeGroupId): its seats;
• seat granularity: every seat (of the scoped section, when there is one);
• inside a section: its rows, tables, GA areas and loose seats;
• at the top level: every object that has no parent (sections, rows and tables outside sections, loose seats, stages, labels, ...).

Bounds of objects together with everything they carry (a table with its chairs, a section with its rows).

Serialises a clipboard payload as JSON with a top-level "openseat/clipboard": 1 marker.

Gives the rows labelled from to to (either way round) of each of sectionIds the ticket type (null clears it), as one undo step: "front 4 rows VIP" across four blocks in one go. Locked rows are left alone. Returns false (with a message) when nothing changed.

Replaces the save handler of a store created by createEditorStore.

The key text for a command on one platform (its first binding there), or null when it has no key. Nudge reads "Arrows"; tools have their own keys (TOOL_KEYS).

A rotation angle in degrees, rounded to 15° steps while Shift is held.

Snaps a drag on each axis independently. Alignment to another object's left/centre/right (or top/middle/bottom), or to an extra lines target, wins when within threshold, and produces a guide line; otherwise the anchor snaps to the grid.

Modifiers: Alt returns the raw delta with no guides. Shift first projects the delta onto the nearest 45° direction and keeps it there: horizontal and vertical moves snap only along their axis, diagonal moves snap one axis (alignment preferred) and derive the other.

Snaps a single point (a drawing click or drag corner) on each axis: to the nearest target coordinate within threshold (with a guide), otherwise to the grid. With alt the point is returned unchanged with no guides.

Per ticket type: the seats buyers pick, the places of zones and of sections sold as a zone (their capacity, not their hidden seats), and the booths. A zone map's ticket types used to read "0 seats", and booth types "0 seats" and ₹0 revenue. What is held back from sale (Not for sale on the map, or a never-sold type) goes to held, not to the counts: three sponsor booths marked Not for sale are not three booths to sell.

Tickets of a type: seats + places + booths (a booth is one ticket, bought by an exhibitor). Held-back ones are not tickets.

An ID prefix (block1, block2, …) no object in the layout uses yet.

The point an object rotates about when its rotation is typed in: a row turns about the centre of its seats' bounds, everything else about its position. Null for unknown IDs.

The venue outline's left, centre and right x and top, middle and bottom y, as snap lines. Empty without a venue.

The layout with ticket type id sold (sellable true: removed from metadata.openseat.unsellableCategories) or never sold (added). The same layout object when nothing changes.

A stage with another outline shape. "rect" removes shape (and the runway); "thrust" keeps or sets the runway (thrust replaces it, null removes it so the default size applies). Never touches the style, so the theme's stage look applies to stages without one.

The drawn rectangle of a zone made without the tool's settings, or undefined.

A new polygon zone through the clicked points (at least 3), like zoneFromRect.

A new zone (GA area, not yet added) filling rect, made by core createZone: rectangle, rounded rectangle or trapezoid (a polygon shape here gives a rectangle; use zoneFromPoints for clicked corners), labelled "Zone N", seated by default, with the capacity and price tier of settings.

A zone to add with EditorActions.addZone. Unset fields come from the Zone tool's settings.

What readClipboardText found: a payload, or null with an error for text that is ours but over a limit.

The editor's command reference: a label, a group and the key binding (if any) of every EditorCommand. Used by the shortcut help overlay, context menus and docs. Key texts come from SHORTCUT_BINDINGS, the table resolveShortcut itself runs on, so they cannot drift.

One currency a host offers for ticket prices ("INR", "₹ Indian rupee").

The host's ticket-price currency, shown as a picker at the top of the Ticket types panel (LayoutEditor's currency). Prices are the host's, so is the currency: the editor only shows the choice and reports a change.

What deleting the selection would affect, so the UI can confirm first.

A change that can remove sold inventory: replacing the layout with a venue template, rebuilding a template layout, or regenerating a table or booth block so that places disappear.

A press-drag-release on the canvas, in layout coordinates.

What dragShapeFor reads: the editor state, or just the parts it needs.

Settings used when drawing rows and making sections parametric.