@openseat/core

Appends objects. IDs must not already exist; validate afterwards if they come from user input.

Moves seats into a row, detaching them from other rows and tables first. They are inserted at atIndex of seatObjectIds, or by their position along the row when omitted. The row is refitted (no seat moves); it stays freeform when no line or arc fits.

Aligns objects to the matching edge or centre of their combined bounds.

Ancestors of an object, nearest first (e.g. a grouped seat: [row, section]).

The outline of a ring segment between two radii and two angles: the outer arc from startAngle to endAngle, then the inner arc back from endAngle to startAngle. An inner radius of 0 or less closes the wedge at the centre instead.

(Re)generates a section's rows and seats from parametric seating, keeping identities:

• Existing rows are taken front to back (rowOrder, else geometrically) and row r keeps its object ID, other fields and label (unless relabel, or the row count changes while every row is still labelled as the section's rowLabeling numbers it: then all rows follow it). Its seats keep their object and public IDs by slot; holes (deleted seats) below the new slot count stay holes; labels follow the seat labeling except for labelLocked seats (or with keepLabels).
• Surplus rows and seats are removed and reported; new rows get fresh IDs and labels that do not collide with the kept rows.
• The section stores seating, its rowOrder, and, when its outline is "auto", an outline recomputed from the seats.

Without seating, the section's current seating is re-applied. Throws a RangeError when the section is missing or the seating is invalid.

Ready-made arenas, each with its ARENA_PRESET_TITLES title:

• "hockey": a 1160 x 540 rink (corner radius 110) in a bowl of about 9,800 seats, numbered clockwise from the top-left corner like a typical NHL arena: a 16-row lower bowl 101-119 (three straight blocks per long side, two per short end, two fans per corner and a third in the top-left, so 101, 118 and 119 share that corner), a ring of single-row 200-level boxes 201-232, and an 18-row upper bowl 301-321 in the same pattern with four blocks per long side. Every short-end section is 7 seats wide.
• "basketball": a smaller court with fully rounded ends and two levels of sections along the sidelines and around the ends.
• "concert-in-round": a round centre stage with fan sections all around.
• "football": a large pitch with square corners, two tiers of sections on every side and a single fan section in each corner.

Assigns objects inside a section's boundary to it. Rows and tables move as a whole: one joins when at least half of its seats are inside (an exact half is decided by the seats' centroid). Loose seats go by their centre and GA areas by their centroid. Seat caches are updated. With mode: "sync", members of this section that now lie fully outside it leave it. count is the number of seats whose centre is inside the boundary.

Tags untagged rows, tables, loose seats and GA areas among ids with the section under their centre (seat centroid for groups, boundary centroid for GA areas). Objects already in a section are left alone.

The exact curvature range applySectionSeating accepts for a block seating, row by row: per-row lengths (rowSeats), aisles and the row's own radius are all taken into account, so it is never stricter or looser than the check itself. min is in [-100, 0] and max in [0, 100]; bound a block's curvature slider with them. minBlockCurvature and maxBlockCurvature are the uniform-row shortcuts for a block that does not exist yet.

True when inner lies entirely inside outer (edges may touch).

True when the rectangles overlap or touch.

Strictly overlapping by more than tolerance on both axes; touching boxes do not overlap.

Builds an arc (wedge) section without adding it: concentric rows between two angles around center, outer rows holding more seats. The section's origin is the area centroid of its ring-segment outline (rotation 0), and the seating stores the centre relative to it; the outline is "auto".

Builds a parametric block section (rows x seats, optionally curved, ragged or staggered) without adding it: the section followed by each row's seats and the row. IDs are unique against layout. Used for drawing previews; createBlockSection adds the result.

Builds the inventory manifest of a layout.

• A seat's effective section is its group's sectionId (row or table; the source of truth), else its own; only sections that exist count. Row and table come from the group that owns the seat.
• Seats appear in document order; positions are rounded to 3 decimals.
• Areas: every GA area; booths only when they have an inventoryId (capacity 1); tables with bookAsWhole (kind "table", capacity = seats); zone sections (showSeats: false) as kind "ga" with objectType: "section", seated: true, inventory ID = the section ID and their zone capacity. The seats, and whole tables, inside a zone section are not sold on their own and are left out of seats and areas.
• Hidden objects are included, whether hidden themselves or through a hidden row, table or section: visibility is an editing and drawing state, not an inventory change, so hiding a section does not drop its seats from the host's inventory. The booking SDK refuses hidden seats.

Optional fields are omitted rather than undefined, so the manifest serialises compactly and compares equal after a JSON round trip.

Generates the rows and seats of a section from its seating, without touching any document. Row r (0 = front) gets the ID ${prefix}:r${r+1}, its slot k the seat object ID ${prefix}:r${r+1}:s${k+1} and the public seat ID ${section.label}-${rowLabel}-${seatLabel} (made unique against existing). Row labels follow section.rowLabeling (A, B, C… by default), seat labels the seating's seatLabeling. Seats take the section's category. Throws a RangeError when the section has no seating or the seating is invalid.

Corners of a width × height rectangle centred on the object's origin, in world space.

Reports structural problems: shared or repeated group members, stale seat caches, duplicate labels, empty rows, uncategorised seats, and invalid parametric fields (row layout, section row order and seating).

Reference checks (dangling IDs) and geometry checks stay in validateLayout; this function assumes nothing about them and skips references it cannot resolve.

Deep-copies the objects of ids (expanded recursively) and the categories they reference into a clipboard payload. Null when nothing is copied.

Turns a polygon into a section in place: same ID, outline, placement, layer flags, category, fill and stroke; the label is the next free section label. Throws a RangeError when polygonId is not a polygon.

Convex hull by Andrew's monotone chain. Returns the hull vertices without a repeated closing point and without collinear points along edges. Fewer than three distinct input points are returned as they are (deduplicated).

buildArcSection plus adding the objects to the layout.

A complete arena layout document: generateArena's objects, venue and categories in a new layout whose focal point is the field centre. When the venue would reach past the top or left canvas edge, everything is moved (by whole grid cells) to make room, and the canvas grows to fit the venue and every object.

buildBlockSection plus adding the objects to the layout.

A new floor divider (not yet added): an open path through the world points (at least 2), 1 unit wide, with caption (trimmed; left out when empty) drawn on it as "▾ CAPTION ▾". Throws a RangeError for fewer than 2 points.

A new footnote label (not yet added) centred at at: 12 units, bold, letter-spaced 0.08 em, in muted grey (#9e9e9e), such as "ALL THE SECTIONS ARE SEATED". Throws a RangeError for empty text.

Creates a random object ID. Does not depend on DOM typings.

Creates an empty layout at the current schema version. The result is not validated; call validateLayout after adding objects.

Wraps the selected rows, tables, loose seats and GA areas (a selected seat stands for its row or table) in a new section with a custom outline around them, and makes them its members. The rows are ordered front to back (nearest the layout's focal point first when it has one). Returns sectionId: null and the same layout when the selection holds nothing that can join a section.

A new GA zone (not yet added to the layout) with an object ID and an inventory ID unused in layout. rect, rounded and trapezoid zones are built from rect and centred on it; a polygon zone from points, its origin at their centroid. A rounded zone gets cornerRadius = min(w, h) × 0.12; a trapezoid keeps one edge w wide and insets the other by 15% on each side (bottom inset by default, top with flip). Throws a RangeError for a degenerate shape, a bad capacity or an empty label.

Everything below an object: a section's rows, tables, GA areas and loose seats, each group followed by its seats; a row's or table's seats. Empty for other objects.

Turns a parametric row into a freeform one. Seats are untouched.

Compares two manifests by public seat ID. A seat ID listed twice in one manifest (an invalid layout) is compared by its first entry.

Removes a section but keeps its contents, which lose their sectionId.

Shortest distance from p to the segment ab.

Spaces objects so their centres are evenly spread between the first and last. Needs three or more.

Spreads count seats over the four edges of a width x height table in proportion to the edge lengths (largest remainder method; ties go to the first edge clockwise from the top).

The text a divider draws for caption: upper-cased between two markers ("▾ GROUND FLOOR ▾").

Copies objects, offset by offset. Sections are copied with their contents and rows and tables with their seats; the copies reference each other. Every copy gets a new object ID and every copied seat a new public seat ID (<old>-copy, then <old>-copy-2, …), so the result never has duplicates. Copies whose section was not copied keep it, unless opts.sectionId says otherwise.

An ellipse of width x height centred on center, clockwise on screen from its rightmost point.

Writes a fitted layout to a row that has none, when the fit reproduces its seats within ROW_LAYOUT_FIT_TOLERANCE. Never moves seats. fitted is true when the row has a layout afterwards; residual is the fit error (0 for rows that already had a layout, Infinity for rows without seats).

Seats generateArena would create for options, computed from the section plans without generating any seat (milliseconds even for invalid sizes). Exact for the generator's default sections; use it to warn about or reject oversized arenas before generating. Throws a GeneratorInputError for invalid options, including a row longer than ARENA_LIMITS.maxSeatsPerRow seats.

Sections generateArena would create for options, without generating any seat. Sides too short for their sections are left empty, so this can be well below the requested counts (a round field has no straight sides). Throws a GeneratorInputError for invalid options.

Conservative box of one line of text: `n × fontSize × (bold ? 0.68 : 0.62)

• letterSpacing × fontSize × (n - 1)wide and1.2 × fontSizehigh, forn` characters. Wider than real text in common UI fonts, so a renderer that shrinks its measured text to fit this box can guarantee that what it draws stays inside what the label layout reserved.

Approximate text box for a label. Exact metrics need a font engine, which core does not have; renderers measure real text, but core needs a stable estimate for hit testing and bounds that does not depend on the browser.

Expands bounds by amount on every side.

Adds everything that moves with the given objects, recursively. A section brings every row, table, GA area and loose seat (a seat in no row or table) whose sectionId is the section; a row or table brings its seats. Moving a table moves its chairs and moving a section moves its contents: this is the single place that rule is defined.

Output order: the known input IDs first (deduplicated), then the added members in document order (the iteration order of objectsById). Unknown IDs are ignored. One pass over the objects, so O(n) per call.

Adds seats at one end of a row (count > 0) or trims them (count < 0). Seats already in the row stay where they are and keep their labels and seat IDs. Extending or trimming the start of a left-to-right numbered row shifts labeling.start so the new seats continue the numbers downwards when that stays at 1 or above; otherwise the new seats continue after the row's highest number, the row's labeling is removed (it keeps custom numbers) and the result's message says so. New seat IDs follow the row's pattern (prefix + label). Never produces label 0, a negative number or a duplicate.

Takes seats out of their rows and tables (parametric rows keep holes, so nothing else moves). With asRow, the seats become a new row (ID row-N, label rowLabel or the next free label) with a fitted layout when one fits. Seats never move.

Text boxes (layoutTextBoxes) that overlap drawn seats (seatBoxes), one entry per text and seat, in text order. At "overview" no seats are drawn (the map shows filled sections), so only "detail" can report overlaps. The check behind the "no text over seats" gate.

Rows whose stored seat positions deviate from their layout by more than tolerance, with the largest deviation. Rows without a layout are skipped.

Grows the canvas until every object fits inside it, with margin to spare. Content above or left of the origin is shifted (all objects together, locked ones included, with the venue outline and focal point) by a whole number of grid cells, so grid alignment survives. The canvas never shrinks; a layout that already fits is returned unchanged.

Fits a parametric layout to seats given in row order. Returns null for no seats. Tries a principal-axis line and a Kasa circle: the line wins when it fits within max(0.5, 2% of the median step) or the circle is nearly flat (radius above 50 times the extent); otherwise the circle wins when it fits within the same tolerance; otherwise the better of the two is returned with its residual. The placement is anchored at the first seat ("start") with the tangent pointing towards the second seat.

Formats a label index. numeric: n >= 0; alpha: n >= 1 in spreadsheet order (1 = A, 26 = Z, 27 = AA); alpha-lower: the same in lowercase; roman: 1..3999, uppercase. Throws a RangeError when n is out of range.

Generates a concentric arena: the field and every tier's sections with their rows and seats, a venue outline and per-tier categories. Section k of a tier (in numbering order) is labelled firstNumber + k; its ID is ${idPrefix}-sec-${label} and its rows and seats follow buildSectionContents (${sectionId}:r1, ${sectionId}:r1:s1, seat IDs ${label}-${row}-${seat}). The field is a stage with the field kind's style and markings. Throws a GeneratorInputError for invalid options, beyond ARENA_LIMITS, or when estimateArenaSeats exceeds ARENA_LIMITS.maxSeats.

Generates a grid of booths numbered left to right, top to bottom. Deterministic IDs.

Generates concentric arc rows. Seats are spaced evenly by angle within each row, or by arc length when seatSpacing is given. Each row gets a parametric layout whose signed radius reproduces the generated seats.

Generates a rectangular table with seats along selected edges. Seats are numbered clockwise starting from the top edge; on each edge the n seats sit at k / (n + 1) of the edge length. The table records the parameters as its arrangement.

Generates a round table with seats spread evenly around it, clockwise from startAngle. The table records the parameters as its arrangement.

Fills a polygon with rows of seats, as for a stadium or arena section.

The rows come from planFillRows: every seat lies fully inside the boundary, and a concave section can give a row several spans. Each row gets a straight parametric layout (span breaks and aisles become gaps), and the section records the fill as seating (kind "fill") with its rowOrder, so it can be refilled later without losing seat IDs.

Generates straight, optionally staggered rows with aisle gaps. Seat positions are absolute layout coordinates. Output is deterministic for the same options. Each row gets a parametric layout (start anchor at its first seat, aisle gaps, seat rotation "row", labeling from the numbering).

The seats of a table arrangement, unrotated around center, with the same IDs and labels as generateRoundTable and generateRectTable. Unlike those, an arrangement without seats gives an empty list.

Returns object IDs in paint order (bottom first). Hit testing walks this order in reverse so the topmost object wins.

Seat object IDs owned by a row or table. Empty for other objects.

World-space axis-aligned bounds of an object, or null for objects with no geometry of their own (rows).

Bounds of the transformed points, computed without a second pass over the input.

Makes a row from loose or grouped seats. Seats are ordered along their principal axis (oriented left to right, or top to bottom when vertical) and detached from any row or table they were in (a parametric source row keeps their slots as holes; a table's capacity follows). Source rows left empty are removed. The row is rotated along its first-to-last seat direction and joins the seats' common section; seat caches (rowLabel, sectionId) are updated. Returns the new row's ID.

True when point hits the shape. tolerance widens the target, which helps touch input.

Builds (or returns the memoised) membership index of a layout. Memoised by the objects array, so every operation on the same immutable document shares one O(n) build (for the most recently used documents).

Converts a zero-based index to a spreadsheet-style label: 0 → A, 25 → Z, 26 → AA. Used for default row labels.

The shared prefix of a group's public seat IDs, for numbering new seats in the same pattern. Returns the longest common prefix that ends in a non-digit when every seat ID is that prefix followed by digits (so c:A:1…c:A:5 gives c:A:), and fallback otherwise.

Infers a table's arrangement from where its seats are, for tables drawn before arrangements existed or edited seat by seat.

• Round: the median distance of the seats from the centre, and the angle of the first seat (seatObjectIds[0]).
• Rect: each seat counts for the edge it lies furthest beyond, in table-local coordinates; the offset is the median distance of the seat centres beyond their edge (the generator's seatOffset).

A table without seats gives the generator defaults (seat radius + 4 clear of the edge, first seat at the top). The table's stored arrangement is ignored; see setTableArrangement for the one in effect.

Inserts count new seats before slot atSlot (0..slotCount). Holes and gaps at or after atSlot shift with the seats; the first retained seat stays where it is.

Existing seats keep their labels and seat IDs. New seats take the labeling's label for their slot when it is free (inserting at slot 0 of a left-to-right row shifts the labeling start down, as extendRow does), else the next number after the row's highest; their seat IDs follow the row's pattern (prefix + label). When the labels then no longer follow the row's labeling, the labeling is removed (the row keeps custom numbers) and the result's message says so.

Inserts a vertex on edge edgeIndex (from vertex edgeIndex to the next; closed outlines wrap around), at world or the edge midpoint.

Result for an unexpected exception inside validation. Validation never throws: a bug or a hostile input that trips one becomes an error instead.

True when the object or any ancestor is hidden. Unknown IDs are not hidden.

True when the object or any ancestor is locked. Unknown IDs are not locked.

A polygon is simple when no two non-adjacent edges touch. Adjacent edges always share a vertex, so they are excluded from the check. See polygonSimplicity for a version with a work budget.

True for a section shown as a zone (showSeats: false): sold by quantity, seats not drawn.

Seat distance for a round table whose radius changes from oldRadius to newRadius: the clear gap oldSeatDistance - oldRadius is kept, floored at the seat radius so seats never slide under the table edge.

Derived places of a row's seats, in seatObjectIds order. Throws when the row has no layout.

World positions and seat rotations of slotCount slots. Rotation is placement.rotation + tangent for "tangent" (the default), placement.rotation for "row", and NaN for "keep".

Every piece of text the layout draws at a level of detail, with its reserved world box: section titles (sectionTitlePlacement), row labels (detail only; resolveRowLabelPlacements, hidden ones left out), zone labels (GA zones and zone sections), stage labels, free labels, divider captions, and table and booth labels (objectLabelPlacement). Hidden objects and the contents of zone sections are left out, and so are seat numbers, which sit inside their seats by design. Memoised per layout object.

Maps a point from an object's local space into layout space. Local points are rotated around the local origin, then translated by position.

Creates a seat object. Optional references are omitted rather than set to undefined, so JSON round trips compare equal.

The strongest positive block curvature at which the longest row (longestRow seats) still fits on the tightest (front) row's radius, with the same limits as minBlockCurvature. Rows grow outwards with positive curvature, so the row count does not matter. 100 when any curvature works.

The most seats a table can take without neighbouring seats coming closer than minGap. Round tables: the seats sit on a circle of radius seatDistance (from a round arrangement, else the radius plus the rect offset), so n seats fit while the chord between neighbours is at least 2 * seatRadius + minGap. Rect tables: the sum over the edges of the seats whose spacing edgeLength / (n + 1) stays at least that pitch (at least one per edge, centred).

The regeneration strategy, in one place:

1. Retain by slot or position. With slots, each generated seat takes over the listed existing seat; otherwise the i-th new seat takes over the i-th existing seat. A retained seat keeps its object ID, public seatId, accessibility metadata, category, name, tags and locked/visible flags. Its sectionId and rowLabel follow the group. Geometry and shape come from the generator. Labels are regenerated unless keepLabels is set or the seat is labelLocked.
2. Add with fresh IDs. New seats get the object ID ${group.id}:s${slot + 1} and a seat ID in the pattern of the group's existing seat IDs (see inferSeatIdPrefix), numbered slot + 1 plus the offset the retained seats share (so a row numbered from 5 continues 9, 10…), made unique against the whole layout.
3. Remove the rest, along with any references to them, and report their public seat IDs.