@seatlayer/js 0.92.5 → 0.94.0

package/dist/{channelsMode-B41tbE29.d.ts → channelsMode-DYwJ6sfR.d.ts}

@@ -644,6 +644,16 @@ interface EventCategoryAssignmentResult {
     categoryKey: string;
     revision: number;
 }
+/** GET /category-assignments: what differs from the chart (list capped, count exact). */
+interface EventCategoryDifferences {
+    chartAvailable: boolean;
+    differing: number;
+    units: Array<{
+        label: string;
+        categoryKey: string;
+        chartCategoryKey: string;
+    }>;
+}
 type EventTableBookingMode = 'individual' | 'whole' | 'variable';
 interface EventTableBookingResult {
     ok: true;
@@ -901,6 +911,15 @@ declare class ManageApi {
      * snapshots retain their original configured value; future selection uses
      * the new category. Requires `event:categories:manage`. */
     setCategory(key: string, labels: string[], categoryKey: string): Promise<EventCategoryAssignmentResult>;
+    /**
+     * The inventory units this event sells under a different category than the
+     * chart currently does — what "Reset to chart defaults" would put back.
+     * Requires `event:view`.
+     */
+    categoryDifferences(key: string): Promise<EventCategoryDifferences>;
+    /** Put every unit (or only `labels`) back on the chart's category, in one
+     * write. Requires `event:categories:manage`. */
+    resetCategoriesToChart(key: string, labels?: string[]): Promise<EventCategoryAssignmentResult>;
     /** Change event-only table booking identity. The server refuses tables with
      * held/booked/blocked inventory or channel assignments that would be lost. */
     setTableBooking(key: string, tableIds: string[], mode: EventTableBookingMode, bounds?: {
@@ -1118,6 +1137,32 @@ declare class ManageApi {
     reportCsv(key: string): Promise<Blob>;
 }
 
+/**
+ * The control room's View menu (plan item 5, slice D).
+ *
+ * Five toggles that change how the map READS, never what it holds: seat
+ * labels, row labels, category colours, channel colours, booking momentum.
+ * The letters are the ones seats.io operators already know (S · R · G · H ·
+ * M), ridden on Shift because the tool tabs own the bare letters (S is
+ * Sections, G is Categories, M is Monitor).
+ *
+ * The set is remembered per browser: an operator who works with labels off
+ * keeps them off tomorrow. Storage is a convenience, never a dependency —
+ * a private window or a blocked store simply starts from the defaults.
+ *
+ * Pure where it can be: the model, the markup and the storage rules are
+ * here and tested without a cockpit; SeatManager owns the state and the
+ * renderer calls.
+ */
+
+interface MapView {
+    seatLabels: boolean;
+    rowLabels: boolean;
+    categoryColours: boolean;
+    channelColours: boolean;
+    momentum: boolean;
+}
+
 /**
  * managerTypes — the SeatManager cockpit's public contract (options, the
  * capability set, the tallies/activity/connection payloads a host subscribes to)
@@ -1180,7 +1225,7 @@ interface SeatManagerActivity {
 }
 /** Fired after a successful organizer action, for host toasts/telemetry. */
 interface SeatManagerActionResult {
-    action: 'block' | 'unblock' | 'unblockAll' | 'cancelBooking' | 'setHoldTtl' | 'setCategory' | 'setTableBooking';
+    action: 'block' | 'unblock' | 'unblockAll' | 'cancelBooking' | 'setHoldTtl' | 'setCategory' | 'resetCategories' | 'setTableBooking';
     labels: string[];
     count: number;
 }
@@ -1330,8 +1375,15 @@ interface SeatManagerOptions {
 }
 /** Realtime link state, as reported to the embedding host. */
 interface SeatManagerConnection {
-    /** `live` while the socket is open; `reconnecting` from drop until reopen. */
-    status: 'live' | 'reconnecting';
+    /**
+     * `live` while the socket is open; `reconnecting` from drop until reopen;
+     * `ended` once the manage session cannot be renewed — the host's
+     * `onTokenRefresh` kept failing (three times running, or with a refusal),
+     * or a 401 arrived with no refresher wired. Nothing polls in `ended`: the
+     * cockpit shows its own "session ended" card with a Try again, and a host
+     * that mints tokens can call `retrySession()` after signing the user in.
+     */
+    status: 'live' | 'reconnecting' | 'ended';
     /**
      * `Date.now()` of the last snapshot or delta accepted from the server, or
      * null before the first one. This is the honest "as of" for whatever the host
@@ -1380,6 +1432,8 @@ declare class SeatManager {
     private activityPanel;
     private navigation;
     private movingMap;
+    /** How a drag on the map chooses seats in the bulk tools: a box, or a freehand lasso (item 5, slice C). */
+    private marqueeShape;
     private socketSnapshotSeen;
     private monitorRefreshTimer;
     /** `'auto'` is kept as asked, not as resolved — see {@link getThemeMode}. */
@@ -1434,6 +1488,12 @@ declare class SeatManager {
     private paintHandle;
     private trendWindowMinutes;
     private heatEnabled;
+    /** The View menu (plan item 5, slice D): labels, colours, momentum — remembered per browser. */
+    private mapView;
+    /** The bar's Find box — its chooser reads every seat, not just the tool's selectable ones. */
+    private barFind;
+    /** The venue overview in the map's corner (plan item 7); null under the compact breakpoint. */
+    private minimap;
     private followLive;
     private lastKpiValues;
     private activeKpiDeltas;
@@ -1459,6 +1519,10 @@ declare class SeatManager {
     private tokenExpiresAt;
     private tokenRefreshTimer;
     private tokenRefreshInFlight;
+    /** Consecutive failed `onTokenRefresh` calls; three in a row end the session. */
+    private tokenRefreshFailures;
+    /** The manage session cannot be renewed: every poll and socket is down until `retrySession()`. */
+    private sessionEnded;
     private sectionByObject;
     private sectionLabelById;
     private sectionsBase;
@@ -1489,6 +1553,16 @@ declare class SeatManager {
      * they do not for as long as a network fetch takes.
      */
     private channels;
+    /**
+     * The shared seat chooser for the tools that choose seats without a mode
+     * object of their own (Block, Categories, Select) — plan item 5. Built per
+     * rail paint, because what is selectable depends on the tool; its dialogs
+     * mount through the manager's one modal primitive.
+     */
+    private chooser;
+    private chooserDialog;
+    /** GET /category-assignments for the Categories tool's Reset count; null until read. */
+    private categoryDifferences;
     private channelCaps;
     private categoryCanManage;
     private tableCanManage;
@@ -1535,6 +1609,32 @@ declare class SeatManager {
      *   has no channels", which is a lie about inventory.
      */
     private ensureChannels;
+    /**
+     * The adapter between the cockpit's internals and the shared seat chooser.
+     * Every list the chooser offers is filtered to what THIS tool may select, so
+     * a picker never adds a seat the tool would then refuse.
+     */
+    private buildChooserHost;
+    /**
+     * The bar's Find (plan item 5, slice D): one box for every tool. Its host
+     * reads EVERY seat — an organizer looking for D-12 does not care whether
+     * the current tool could select it — and Enter selects on the choosing
+     * tools, frames on Inspect and Monitor. Highlight rides the renderer.
+     */
+    private wireBarFind;
+    private isChoosingTool;
+    /** Move the camera to these seats — Enter in the bar's Find on Inspect/Monitor. */
+    private frameLabels;
+    /** Find's highlight on the map: labels → ids; null clears. */
+    private highlightLabels;
+    /** A fresh chooser for the rail being painted (selectability is per tool). */
+    private toolChooser;
+    /**
+     * The one line under every chooser: the count, what the tool says about the
+     * selection, Select all and Clear. `data-ref` names are the tool's own so
+     * its painters keep addressing them.
+     */
+    private toolSelectionBar;
     /** The adapter between the cockpit's internals and Channels mode. */
     private buildChannelsHost;
     /** Actual on-screen seat diameter, for the channel overlay's marks. The
@@ -1544,6 +1644,19 @@ declare class SeatManager {
     private seatPixelSize;
     /** Toggle the normalized sales-velocity outline overlay without changing seat colors. */
     setHeatOverlay(enabled: boolean): void;
+    /**
+     * The View menu (plan item 5, slice D): seat labels, row labels, category
+     * colours, channel colours, booking momentum. Each is a toggle the map
+     * applies at once; the whole set is remembered per browser so an operator
+     * who works with labels off keeps them off tomorrow.
+     */
+    setMapView(patch: Partial<MapView>): void;
+    getMapView(): MapView;
+    private toggleMapView;
+    /** Channel colours are the Channels tool's overlay; outside it there is nothing to colour by. */
+    private channelColoursAvailable;
+    private applyMapView;
+    private paintMapViewMenu;
     /** Toggle opt-in camera following for new buyer hold/book events. */
     setFollowLive(enabled: boolean): void;
     /** Update background-tab repaint policy without rebuilding the board. */
@@ -1609,6 +1722,18 @@ declare class SeatManager {
     setToken(token: EventScopedManageToken, expiresAt?: number): void;
     private scheduleTokenRefresh;
     private rotateToken;
+    /**
+     * The manage session cannot be renewed. Every timer, poll and socket
+     * stops; the map stays painted as it was, under a card that says so and
+     * offers one Try again. The host hears `status: 'ended'` once.
+     */
+    private endSession;
+    /**
+     * Ask the host for a token once more — after it signed the user back in —
+     * and, if it answers, pick the live stream up where it stopped.
+     */
+    retrySession(): Promise<boolean>;
+    private paintSessionEnded;
     /** Bulk block the given labels (or the current selection when omitted). */
     block(labels?: string[], opts?: {
         releaseAt?: number;
@@ -1676,11 +1801,49 @@ declare class SeatManager {
     }>;
     setHoldTtl(ms: number | null): Promise<void>;
     zoomToFit(): void;
+    /**
+     * "−" walks back one level — seats → the section → the venue — the way the
+     * buyer picker's does; leaving a focused section also drops the focus. A
+     * renderer without the level walk falls back to the factor step.
+     */
+    private zoomOutStep;
+    /**
+     * What the map chrome reads: the camera, the focus, the floor, and the
+     * live counts the minimap snapshot carries (plan item 7). Painted on every
+     * view change, so the crumb and the pills never lag the camera.
+     */
+    private paintMapChrome;
+    /** The renderer as a {@link MapCamera}, for the minimap and any other map chrome. */
+    private mapCamera;
+    /**
+     * The venue overview in the map's corner. Not under the compact breakpoint
+     * — the pills stay, the thumbnail goes — and rebuilt with the renderer so a
+     * chart change never leaves a stale outline behind.
+     */
+    private syncMinimap;
+    private cssVar;
     destroy(): void;
     private buildRenderer;
+    /**
+     * The organizer's facts on the map's hover card (plan item 5, slice D):
+     * STATUS · CHANNEL · FOR SALE, in one glance. CHANNEL appears once the
+     * Channels list has loaded — a guess would be worse than a missing cell.
+     * FOR SALE is the buyer's truth: free, its section open and shown, and its
+     * category sellable.
+     */
+    private hoverFactsFor;
     /** Block always uses a marquee. Channels only enables its marquee after the
      * organizer deliberately chooses Assign seats; Pan map keeps desktop drag
      * available for large charts. */
+    /** A tap on a row label takes the row in every tool that chooses seats. */
+    private rowLabelSelectable;
+    /**
+     * The two map intents a choosing tool offers beside the chooser's pickers:
+     * drag a box, or draw a lasso. One is always on; the choice survives a
+     * repaint and a tool switch (an operator who prefers the lasso keeps it).
+     */
+    private marqueeShapeChipsHtml;
+    private wireMarqueeShapeChips;
     private isBulkSelectMode;
     /**
      * Block never touches held or booked inventory, so it cannot select it.
@@ -1845,6 +2008,7 @@ declare class SeatManager {
      */
     private railHeader;
     private paintFollowLiveButton;
+    /** Booking momentum lives in the View menu now; this keeps the item and the status line current. */
     private paintHeatButton;
     private paintMomentumHelp;
     private paintFullscreenButton;
@@ -1866,6 +2030,15 @@ declare class SeatManager {
     /** Seats in a chart category that the operator may act on in this mode. */
     private categorySeats;
     private renderCategoriesRail;
+    /**
+     * "Reset to chart defaults" says how many seats it would move BEFORE it is
+     * pressed, and is disabled when the answer is none — a button that says
+     * "reset" over a chart-identical event would be a lie.
+     */
+    private loadCategoryDifferences;
+    private paintCategoryReset;
+    /** One click, no confirm (owner, 2026-09-20): the button already says what it will move. */
+    resetCategoriesToChart(): Promise<void>;
     private paintCategorySelection;
     private renderTablesRail;
     private renderInspectRail;
@@ -1898,13 +2071,11 @@ declare class SeatManager {
     private paintLegend;
     private paintFeed;
     private renderBlockRail;
-    private toggleCategory;
     /** A category/filter is a real toggle: add the missing seats, or remove the
      * whole group when every eligible seat in it is already selected. */
     private toggleLabels;
     private isBlockSelectable;
     private paintSelBar;
-    private paintCategoryControls;
     private filteredBlockedSeats;
     private paintBlockedInventory;
     private confirmUnblockAll;
@@ -2132,7 +2303,14 @@ declare class ChannelsMode {
     private conflict;
     private dialog;
     private detent;
-    private seatListLimit;
+    /**
+     * The shared seat chooser (plan item 5): the sections/rows dialog, the
+     * category picker, the seat list and Find. Channels was the first caller —
+     * those dialogs were written here and moved out unchanged — and paints its
+     * dialogs through this mode's own scrim so every Channels sheet shares one
+     * focus trap.
+     */
+    private readonly chooser;
     /**
      * Hosted-link STATUS for the channel whose detail panel is open. This is the
      * listing projection — it carries no url and no capability, because no route
@@ -2167,6 +2345,7 @@ declare class ChannelsMode {
     private pollTimer;
     private layer;
     private canvas;
+    private overlayVisible;
     /** undefined = not resolved yet, null = this environment has no 2d canvas. */
     private ctx;
     private bannerEl;
@@ -2177,10 +2356,6 @@ declare class ChannelsMode {
     private stagedDoneTimer;
     private lastSelectionCount;
     private lastCounts;
-    /** Rows are structural chart data — they do not move while the organizer is
-     * allocating. Deriving them walks every seat, so the view is cached for the
-     * lifetime of this mode entry and ordinary selection repaints stay O(1). */
-    private assignmentRowsCache;
     /** The markup currently in the rail. An identical repaint is skipped, which is
      *  what keeps the organizer's scroll position (and open <select>) alive. */
     private railHtml;
@@ -2232,6 +2407,12 @@ declare class ChannelsMode {
     private loadAllocation;
     private channelById;
     private nameOf;
+    /**
+     * The channel a seat is allocated to, by name, for the map's hover card —
+     * null until the list has loaded (the card then shows no CHANNEL cell rather
+     * than a wrong "Public sale"). Unallocated = the public sale channel.
+     */
+    channelNameForLabel(label: string): string | null;
     private markerFor;
     /** Channels an organizer may assign INTO: public sale plus every live channel. */
     private assignableChannels;
@@ -2245,6 +2426,13 @@ declare class ChannelsMode {
      * the guards, the memoised 2D context, and the command the section hit targets
      * fire back into the rail.
      */
+    /**
+     * The View menu's "Channel colours" (plan item 5, slice D): the letter
+     * flags and section tints are this tool's overlay, and the menu can put
+     * them away while the tool stays open. Hidden = the canvas is cleared and
+     * the flags are gone; the staged bar, banner and live line stay.
+     */
+    setOverlayVisible(visible: boolean): void;
     private paintOverlay;
     private setStaged;
     private paintStagedBar;
@@ -2348,24 +2536,8 @@ declare class ChannelsMode {
     /** Open a channel's detail panel and start its buyer-link read. */
     private openChannel;
     private railAction;
-    /** Derived once per mode entry — see `assignmentRowsCache`. */
-    private assignmentRows;
     private pickCategory;
-    /** A tiny modal chooser reusing the dialog primitive (focus trap + Escape). */
-    private promptChoice;
-    /**
-     * Add several whole sections, or several whole rows, in one operation.
-     *
-     * ADDITIVE by contract: the chooser starts from the labels already selected
-     * and only ever grows that set, so opening it never destroys a hard-won
-     * marquee or seat-list selection. The confirm button always states the net
-     * number of seats it will add, and refuses to exceed `MAX_ASSIGNMENT_UNITS`.
-     *
-     * Rows get the richer variant. A large venue has thousands of them, so they
-     * arrive collapsed under their section, with a section-level tri-state
-     * checkbox, a search across every row, and a render cap — the flat list used
-     * for sections would be an unusable wall of buttons.
-     */
+    /** The additive sections/rows chooser — shared (seatChooser.ts); the dialog state keeps it re-renderable. */
     private renderScopeDialog;
     private openDialog;
     private renderDialog;
@@ -2461,6 +2633,7 @@ declare class ChannelsMode {
      * equivalent of canvas click / marquee / brush, grouped by section with
      * per-section select actions.
      */
+    /** The keyboard seat list — shared (seatChooser.ts), with the channel beside each seat. */
     private renderSeatListDialog;
     private reloadLinks;
     /**

package/dist/channelsMode-YJO6FOPD.js

@@ -0,0 +1 @@
+import{T as a,U as b,V as c}from"./chunk-DR5JXWLO.js";import"./chunk-RZ2VKZ44.js";import"./chunk-OSZ7DOEH.js";export{b as CHANNELS_CSS,c as ChannelsMode,a as bucketRowsHtml};