@seatlayer/core 0.53.0 → 0.54.0

package/dist/sections-mLOZrGrI.d.ts

@@ -0,0 +1,123 @@
+import { d as SectionObject, C as ChartDoc } from './types-COfJorq_.js';
+
+/**
+ * Real-world scale primitives — the ONE place the app fixes chart-unit ↔ metre ↔
+ * renderer-world scale, and the section 3D-geometry resolver that rides on it.
+ *
+ * Everything that converts between chart units, metres, and renderer "world"
+ * units derives from {@link METRES_PER_CHART_UNIT}. Renderer world units and
+ * chart units are 1:1, so metres → world is exactly {@link CHART_UNITS_PER_METRE}
+ * (the single m→world conversion constant Phase B consumers use).
+ *
+ * This is a leaf module (types only) so both `layout.ts` and `sections.ts` can
+ * import it without the two forming an import cycle.
+ */
+
+/**
+ * Metres of front-edge height one elevation tier represents. Chosen (not guessed)
+ * so `elevation × TIER_HEIGHT_M` metres, scaled back through
+ * {@link CHART_UNITS_PER_METRE}, equals the legacy `elevation × LIFT_PER_STEP`
+ * world lift exactly — an un-authored chart stays pixel-identical. ≈ 1.329 m/tier.
+ */
+declare const TIER_HEIGHT_M: number;
+/**
+ * Resolve a section's real 3D geometry, applying the legacy-elevation fallback so
+ * old charts and new charts share ONE code path. Every consumer (iso lift, 360°
+ * eye-height, author lint, any 2D depth cue) must call this and never read the raw
+ * {@link SectionObject.height}/{@link SectionObject.rake} fields — that is what
+ * keeps un-authored charts rendering identically to today.
+ *
+ * - `height`: authored absolute metres if present, else owning-floor base height
+ *   plus `elevation × TIER_HEIGHT_M`.
+ * - `rake`: authored degrees if present, else 0 (flat).
+ *
+ * Malformed values are bounded here as a last defensive barrier. Structural
+ * validation still reports them so drafts can be repaired instead of silently
+ * persisting a renderer-only interpretation.
+ *
+ * Pure — no document mutation, no side effects.
+ */
+interface SectionGeometryContext {
+    /** Absolute physical height of the owning floor above the venue datum. */
+    floorBaseHeightM?: number;
+}
+declare function sectionGeometry(section: Pick<SectionObject, 'elevation' | 'height' | 'rake'>, context?: SectionGeometryContext): {
+    height: number;
+    rake: number;
+};
+
+/**
+ * Section membership + hide/show resolution (Batch 3.3).
+ *
+ * A `SectionObject` is a polygon drawn over existing seat objects; an object
+ * "belongs" to a section when its visual centre (`objectCenter`) falls inside
+ * the section outline, first section in doc order winning. This is the same
+ * spatial notion `objectCenter`'s doc-comment describes, resolved once here so
+ * BOTH the event manager (Sections tab counts) and the buyer picker (omit
+ * hidden seats) agree on which seats live in which section.
+ *
+ * Hiding is per-EVENT (the EventDO holds the hidden id set), not a chart edit —
+ * so a republish of the chart never disturbs it. A hidden id may be a section
+ * id, a zone id (hides every section in the zone), or `UNGROUPED_ID` (the
+ * catch-all bucket of seat objects that sit in no section).
+ */
+
+/** Synthetic section id for seat objects that fall in no drawn section. */
+declare const UNGROUPED_ID = "__ungrouped__";
+/**
+ * A per section/zone availability window (Batch 3.4). Wire-compatible with the
+ * EventDO's own `AvailabilityRule`. Absence of a rule for an id = on sale.
+ *   'hidden'    — manual: hidden until the organizer reveals it (3.3).
+ *   'timed'     — hidden until `revealAt` (epoch ms), then auto-reveals.
+ *   'threshold' — auto-reveals once the on-sale inventory is `thresholdPct`% sold.
+ *   'closed'    — visible to buyers but not purchasable (rendered flat grey);
+ *                 unlike 'hidden', the seats stay on the map, just off sale.
+ * `labels` are the seat labels the id governs, so a threshold's denominator can
+ * exclude still-hidden seats.
+ */
+interface AvailabilityRule {
+    mode: 'hidden' | 'timed' | 'threshold' | 'closed';
+    revealAt?: number;
+    thresholdPct?: number;
+    labels?: string[];
+}
+interface SectionNode {
+    /** Section id (a `SectionObject.id`, or `UNGROUPED_ID`). */
+    id: string;
+    label: string;
+    /** Zone id this section points at (`SectionObject.zone`), if any. */
+    zone?: string;
+    /** Total seats across the member objects. */
+    seatCount: number;
+    /** Ids of the seat-bearing objects that belong to this section. */
+    objectIds: string[];
+    /** Seat labels across the member objects (for availability-rule denominators). */
+    seatLabels: string[];
+}
+/**
+ * Resolve section membership for a chart. Returns one node per drawn section
+ * (doc order), a synthetic "Ungrouped" node for loose seat objects (null when
+ * every seat sits in a section), and the object→section id map.
+ */
+declare function computeSections(doc: ChartDoc): {
+    sections: SectionNode[];
+    ungrouped: SectionNode | null;
+    /** seat-object id → owning section id (or `UNGROUPED_ID`). */
+    objectToSection: Map<string, string>;
+};
+/** Is a drawn section hidden under `hidden` — directly, or via its zone? */
+declare function isSectionHidden(s: SectionObject, hidden: ReadonlySet<string>): boolean;
+/**
+ * The set of seat-object ids to omit from the buyer view for a given hidden id
+ * set. An object is hidden when its owning section is hidden (directly or via
+ * zone), or it is ungrouped and the catch-all bucket is hidden.
+ */
+declare function hiddenObjectIds(doc: ChartDoc, hidden: ReadonlySet<string>): Set<string>;
+/**
+ * A copy of the doc with hidden sections' member objects removed, plus the
+ * hidden section overlays themselves (so no empty block renders). Returns the
+ * SAME reference when nothing is hidden — callers can skip a re-render on `===`.
+ */
+declare function applyHidden(doc: ChartDoc, hidden: ReadonlySet<string>): ChartDoc;
+
+export { type AvailabilityRule as A, type SectionNode as S, TIER_HEIGHT_M as T, UNGROUPED_ID as U, applyHidden as a, computeSections as c, hiddenObjectIds as h, isSectionHidden as i, sectionGeometry as s };

package/dist/segmentedRowModel-BPTnJ7Tz.d.ts

@@ -0,0 +1,75 @@
+import { P as Point, R as RowObject, c as ChartObject } from './types-COfJorq_.js';
+
+/**
+ * The segmented-row model — one logical row made of several physical rows.
+ *
+ * A segmented row is drawn as a chain of nodes and stored as N physical
+ * `RowObject`s tied together by `segmentedRow` metadata. Two questions have to
+ * be answered consistently or the feature lies to somebody:
+ *
+ * 1. **At draft time** — given the author's nodes, exactly which components,
+ *    seat counts and pitches will be committed? (`segmentedRowComponents`)
+ * 2. **At read time** — given stored physical rows, what is the logical row they
+ *    form, and where does each component sit inside its numbering?
+ *    (`resolveSegmentedRowGroups`)
+ *
+ * These lived apart — (1) in `rowDraft.ts` next to the ghost preview, (2) in
+ * `layout.ts` next to buyer expansion — which is precisely how the canvas came
+ * to number a segmented row `1-7` / `1-6` while buyers correctly saw
+ * `A-1…A-13`. They are two halves of one rule, so they live in one module.
+ *
+ * The standing rule this module exists to enforce: **the ghost preview and the
+ * commit share one resolver.** A preview that can lie is a bug.
+ */
+
+/** One physical component of a segmented (node-drawn) row. */
+interface SegmentedRowComponent {
+    origin: Point;
+    /** Bearing in degrees, matching RowObject.rotation. */
+    rotation: number;
+    seatCount: number;
+    /** Pitch is per-component: each span divides evenly into whole seats. */
+    seatSpacing: number;
+}
+/**
+ * Resolve node points into the exact components `finishSegmentedRowDrawing`
+ * commits, so the ghost preview and the committed rows always agree.
+ *
+ * `boundaries[i]` describes the junction BEFORE component i+1. The first
+ * component owns the first node's seat; every later component starts one pitch
+ * after its junction so a continuous bend never double-books a seat, and a
+ * declared break skips two pitches to leave a visible aisle.
+ */
+declare function segmentedRowComponents(points: readonly Point[], boundaries: readonly ('continuous' | 'break')[], seatSpacing: number): SegmentedRowComponent[];
+/** Seat centres for a resolved component, in seat order. */
+declare function segmentedRowComponentSeats(component: SegmentedRowComponent): Point[];
+/** Total seats a segmented draft would commit — the number the badge shows. */
+declare function segmentedRowSeatTotal(components: readonly SegmentedRowComponent[]): number;
+/** Resolved logical placement of one physical component inside a segmented row. */
+interface SegmentedRowPlacement {
+    groupId: string;
+    /** Buyer adjacency index base (a declared aisle break costs one index). */
+    adjacencyOffset: number;
+    /** Continuous seat-numbering base across the whole logical row. */
+    displayOffset: number;
+    displayLabel: string;
+    totalSeats: number;
+    canonical: RowObject;
+    viewFromSeatUrl?: string;
+    viewFromSeatMeta?: RowObject['viewFromSeatMeta'];
+    confidenceEvidence?: RowObject['confidenceEvidence'];
+}
+/**
+ * Group physical rows into their logical segmented rows, keyed by physical row id.
+ *
+ * Resolves only complete, internally coherent groups. Malformed metadata is
+ * surfaced by validation and deliberately falls back to physical-row semantics,
+ * so a corrupt document can never make buyer adjacency more permissive than the
+ * legacy model.
+ *
+ * Shared by buyer expansion AND the Designer canvas so a segmented row cannot be
+ * numbered one way for buyers and another way for the author.
+ */
+declare function resolveSegmentedRowGroups(objects: readonly ChartObject[]): Map<string, SegmentedRowPlacement>;
+
+export { type SegmentedRowPlacement as S, type SegmentedRowComponent as a, segmentedRowComponents as b, segmentedRowSeatTotal as c, resolveSegmentedRowGroups as r, segmentedRowComponentSeats as s };

package/dist/segmentedRowModel-CGoH684F.d.cts

@@ -0,0 +1,75 @@
+import { P as Point, R as RowObject, c as ChartObject } from './types-COfJorq_.cjs';
+
+/**
+ * The segmented-row model — one logical row made of several physical rows.
+ *
+ * A segmented row is drawn as a chain of nodes and stored as N physical
+ * `RowObject`s tied together by `segmentedRow` metadata. Two questions have to
+ * be answered consistently or the feature lies to somebody:
+ *
+ * 1. **At draft time** — given the author's nodes, exactly which components,
+ *    seat counts and pitches will be committed? (`segmentedRowComponents`)
+ * 2. **At read time** — given stored physical rows, what is the logical row they
+ *    form, and where does each component sit inside its numbering?
+ *    (`resolveSegmentedRowGroups`)
+ *
+ * These lived apart — (1) in `rowDraft.ts` next to the ghost preview, (2) in
+ * `layout.ts` next to buyer expansion — which is precisely how the canvas came
+ * to number a segmented row `1-7` / `1-6` while buyers correctly saw
+ * `A-1…A-13`. They are two halves of one rule, so they live in one module.
+ *
+ * The standing rule this module exists to enforce: **the ghost preview and the
+ * commit share one resolver.** A preview that can lie is a bug.
+ */
+
+/** One physical component of a segmented (node-drawn) row. */
+interface SegmentedRowComponent {
+    origin: Point;
+    /** Bearing in degrees, matching RowObject.rotation. */
+    rotation: number;
+    seatCount: number;
+    /** Pitch is per-component: each span divides evenly into whole seats. */
+    seatSpacing: number;
+}
+/**
+ * Resolve node points into the exact components `finishSegmentedRowDrawing`
+ * commits, so the ghost preview and the committed rows always agree.
+ *
+ * `boundaries[i]` describes the junction BEFORE component i+1. The first
+ * component owns the first node's seat; every later component starts one pitch
+ * after its junction so a continuous bend never double-books a seat, and a
+ * declared break skips two pitches to leave a visible aisle.
+ */
+declare function segmentedRowComponents(points: readonly Point[], boundaries: readonly ('continuous' | 'break')[], seatSpacing: number): SegmentedRowComponent[];
+/** Seat centres for a resolved component, in seat order. */
+declare function segmentedRowComponentSeats(component: SegmentedRowComponent): Point[];
+/** Total seats a segmented draft would commit — the number the badge shows. */
+declare function segmentedRowSeatTotal(components: readonly SegmentedRowComponent[]): number;
+/** Resolved logical placement of one physical component inside a segmented row. */
+interface SegmentedRowPlacement {
+    groupId: string;
+    /** Buyer adjacency index base (a declared aisle break costs one index). */
+    adjacencyOffset: number;
+    /** Continuous seat-numbering base across the whole logical row. */
+    displayOffset: number;
+    displayLabel: string;
+    totalSeats: number;
+    canonical: RowObject;
+    viewFromSeatUrl?: string;
+    viewFromSeatMeta?: RowObject['viewFromSeatMeta'];
+    confidenceEvidence?: RowObject['confidenceEvidence'];
+}
+/**
+ * Group physical rows into their logical segmented rows, keyed by physical row id.
+ *
+ * Resolves only complete, internally coherent groups. Malformed metadata is
+ * surfaced by validation and deliberately falls back to physical-row semantics,
+ * so a corrupt document can never make buyer adjacency more permissive than the
+ * legacy model.
+ *
+ * Shared by buyer expansion AND the Designer canvas so a segmented row cannot be
+ * numbered one way for buyers and another way for the author.
+ */
+declare function resolveSegmentedRowGroups(objects: readonly ChartObject[]): Map<string, SegmentedRowPlacement>;
+
+export { type SegmentedRowPlacement as S, type SegmentedRowComponent as a, segmentedRowComponents as b, segmentedRowSeatTotal as c, resolveSegmentedRowGroups as r, segmentedRowComponentSeats as s };

package/dist/ticketRestrictions-BwAebpSK.d.cts

@@ -0,0 +1,72 @@
+import { C as ChartDoc, G as GAAreaObject, k as GAInventorySegment, l as CategoryTier } from './types-COfJorq_.cjs';
+import { E as ExpandedSeat } from './renderer-DhUHFtsI.cjs';
+
+declare const MAX_GA_CAPACITY = 100000;
+declare const MAX_EVENT_INVENTORY = 100000;
+/** Stable internal inventory label for one unit of a GA area's capacity. */
+declare function gaUnitLabel(areaId: string, index: number): string;
+/** Strict, bounded validation for durable Join Areas inventory provenance. */
+declare function validGAInventorySegments(area: GAAreaObject): boolean;
+/** Canonical source ranges. Invalid explicit provenance intentionally yields no
+ * labels: chart validation blocks publication instead of inventing identities. */
+declare function gaInventorySegments(area: GAAreaObject): GAInventorySegment[];
+declare function gaUnitLabels(area: GAAreaObject): string[];
+/** Append-only capacity semantics for an already joined GA surface. */
+declare function growJoinedGAInventory(area: GAAreaObject, nextCapacity: number): GAInventorySegment[] | undefined;
+declare function gaAreasOf(doc: ChartDoc): GAAreaObject[];
+declare function isGaUnitLabel(label: string): boolean;
+
+interface TicketSelection {
+    label: string;
+    tierId?: string | null;
+}
+interface CompanionSelectionIssue {
+    code: 'companion_pair_required';
+    labels: string[];
+    message: string;
+}
+interface TicketOptionApplicabilityIssue {
+    code: 'ticket_option_not_applicable';
+    labels: string[];
+    message: string;
+}
+interface NotForSaleSelectionIssue {
+    code: 'not_for_sale';
+    labels: string[];
+    message: string;
+}
+type TicketSelectionIssue = CompanionSelectionIssue | TicketOptionApplicabilityIssue | NotForSaleSelectionIssue;
+type TicketTierResolution = {
+    kind: 'none';
+} | {
+    kind: 'resolved';
+    tier: CategoryTier;
+} | {
+    kind: 'invalid';
+};
+declare function ticketOptionNotApplicableIssue(labels: string[]): TicketOptionApplicabilityIssue;
+declare function ticketTierAppliesToSeat(tier: CategoryTier, seat: Pick<ExpandedSeat, 'label' | 'accessibility'>): boolean;
+/** Ticket choices that are genuinely applicable to this native inventory unit. */
+declare function applicableTicketTiers(doc: ChartDoc, seat: Pick<ExpandedSeat, 'label' | 'categoryKey' | 'accessibility'>): CategoryTier[];
+/**
+ * One deterministic default for every buyer path. A category without tiers
+ * keeps its ordinary category price. A tiered category resolves an omitted id
+ * to its first applicable authored tier and fails closed when none applies.
+ */
+declare function resolveTicketTierForSeat(doc: ChartDoc, seat: Pick<ExpandedSeat, 'label' | 'categoryKey' | 'accessibility'>, tierId?: string | null): TicketTierResolution;
+/**
+ * Enforce only the companion relationship the chart states explicitly. A
+ * display name such as "Companion" is deliberately not semantic evidence.
+ * The paired wheelchair place must be selected and adjacent in the authored
+ * logical row; aisle gaps therefore cannot accidentally satisfy the rule.
+ */
+declare function companionSelectionIssue(doc: ChartDoc, selections: readonly TicketSelection[]): CompanionSelectionIssue | null;
+/**
+ * Shared buyer/server ticket validation. Applicability is checked before the
+ * companion relationship so a forged tier id cannot be disguised as a pairing
+ * problem. Unknown labels/tier ids remain the caller's ordinary invalid-selection
+ * concern; this function owns only explicit chart semantics.
+ */
+declare function ticketSelectionIssue(doc: ChartDoc, selections: readonly TicketSelection[]): TicketSelectionIssue | null;
+
+export { type CompanionSelectionIssue as C, MAX_EVENT_INVENTORY as M, type NotForSaleSelectionIssue as N, type TicketOptionApplicabilityIssue as T, MAX_GA_CAPACITY as a, type TicketSelection as b, type TicketSelectionIssue as c, type TicketTierResolution as d, applicableTicketTiers as e, companionSelectionIssue as f, gaAreasOf as g, gaInventorySegments as h, gaUnitLabel as i, gaUnitLabels as j, growJoinedGAInventory as k, isGaUnitLabel as l, ticketSelectionIssue as m, ticketTierAppliesToSeat as n, resolveTicketTierForSeat as r, ticketOptionNotApplicableIssue as t, validGAInventorySegments as v };

package/dist/ticketRestrictions-ChHJwvTq.d.ts

@@ -0,0 +1,72 @@
+import { C as ChartDoc, G as GAAreaObject, k as GAInventorySegment, l as CategoryTier } from './types-COfJorq_.js';
+import { E as ExpandedSeat } from './renderer-IBi9YKWR.js';
+
+declare const MAX_GA_CAPACITY = 100000;
+declare const MAX_EVENT_INVENTORY = 100000;
+/** Stable internal inventory label for one unit of a GA area's capacity. */
+declare function gaUnitLabel(areaId: string, index: number): string;
+/** Strict, bounded validation for durable Join Areas inventory provenance. */
+declare function validGAInventorySegments(area: GAAreaObject): boolean;
+/** Canonical source ranges. Invalid explicit provenance intentionally yields no
+ * labels: chart validation blocks publication instead of inventing identities. */
+declare function gaInventorySegments(area: GAAreaObject): GAInventorySegment[];
+declare function gaUnitLabels(area: GAAreaObject): string[];
+/** Append-only capacity semantics for an already joined GA surface. */
+declare function growJoinedGAInventory(area: GAAreaObject, nextCapacity: number): GAInventorySegment[] | undefined;
+declare function gaAreasOf(doc: ChartDoc): GAAreaObject[];
+declare function isGaUnitLabel(label: string): boolean;
+
+interface TicketSelection {
+    label: string;
+    tierId?: string | null;
+}
+interface CompanionSelectionIssue {
+    code: 'companion_pair_required';
+    labels: string[];
+    message: string;
+}
+interface TicketOptionApplicabilityIssue {
+    code: 'ticket_option_not_applicable';
+    labels: string[];
+    message: string;
+}
+interface NotForSaleSelectionIssue {
+    code: 'not_for_sale';
+    labels: string[];
+    message: string;
+}
+type TicketSelectionIssue = CompanionSelectionIssue | TicketOptionApplicabilityIssue | NotForSaleSelectionIssue;
+type TicketTierResolution = {
+    kind: 'none';
+} | {
+    kind: 'resolved';
+    tier: CategoryTier;
+} | {
+    kind: 'invalid';
+};
+declare function ticketOptionNotApplicableIssue(labels: string[]): TicketOptionApplicabilityIssue;
+declare function ticketTierAppliesToSeat(tier: CategoryTier, seat: Pick<ExpandedSeat, 'label' | 'accessibility'>): boolean;
+/** Ticket choices that are genuinely applicable to this native inventory unit. */
+declare function applicableTicketTiers(doc: ChartDoc, seat: Pick<ExpandedSeat, 'label' | 'categoryKey' | 'accessibility'>): CategoryTier[];
+/**
+ * One deterministic default for every buyer path. A category without tiers
+ * keeps its ordinary category price. A tiered category resolves an omitted id
+ * to its first applicable authored tier and fails closed when none applies.
+ */
+declare function resolveTicketTierForSeat(doc: ChartDoc, seat: Pick<ExpandedSeat, 'label' | 'categoryKey' | 'accessibility'>, tierId?: string | null): TicketTierResolution;
+/**
+ * Enforce only the companion relationship the chart states explicitly. A
+ * display name such as "Companion" is deliberately not semantic evidence.
+ * The paired wheelchair place must be selected and adjacent in the authored
+ * logical row; aisle gaps therefore cannot accidentally satisfy the rule.
+ */
+declare function companionSelectionIssue(doc: ChartDoc, selections: readonly TicketSelection[]): CompanionSelectionIssue | null;
+/**
+ * Shared buyer/server ticket validation. Applicability is checked before the
+ * companion relationship so a forged tier id cannot be disguised as a pairing
+ * problem. Unknown labels/tier ids remain the caller's ordinary invalid-selection
+ * concern; this function owns only explicit chart semantics.
+ */
+declare function ticketSelectionIssue(doc: ChartDoc, selections: readonly TicketSelection[]): TicketSelectionIssue | null;
+
+export { type CompanionSelectionIssue as C, MAX_EVENT_INVENTORY as M, type NotForSaleSelectionIssue as N, type TicketOptionApplicabilityIssue as T, MAX_GA_CAPACITY as a, type TicketSelection as b, type TicketSelectionIssue as c, type TicketTierResolution as d, applicableTicketTiers as e, companionSelectionIssue as f, gaAreasOf as g, gaInventorySegments as h, gaUnitLabel as i, gaUnitLabels as j, growJoinedGAInventory as k, isGaUnitLabel as l, ticketSelectionIssue as m, ticketTierAppliesToSeat as n, resolveTicketTierForSeat as r, ticketOptionNotApplicableIssue as t, validGAInventorySegments as v };