@seatlayer/core 0.53.0 → 0.54.0

package/dist/core/sections/index.d.ts

@@ -0,0 +1,346 @@
+import { P as Point, R as RowObject, S as SeatOverride } from '../../types-COfJorq_.js';
+export { D as DEFAULT_SECTION_CORNER_SMOOTHING, M as MAX_EDGE_SAGITTA_RATIO, R as RelabelOptions, S as SectionOutlineDerivation, i as indexLabel, r as relabelRows, a as reverseSectionOutlinePath, s as sampleSectionOutlinePath, b as sectionCornerSmoothingPath, c as sectionOutlinePathFrom, d as sectionPathSegmentEnd, t as toBijectiveBase, e as toLetters, f as toRoman, g as transformSectionOutlinePath, h as translateSectionOutlinePath, v as validSectionOutlinePath } from '../../labeling-w8bl86cb.js';
+export { SeatConfidenceDisclosure, seatConfidenceDisclosure } from '../seatConfidence.js';
+import { S as SegmentedRowPlacement } from '../../segmentedRowModel-BPTnJ7Tz.js';
+export { A as AvailabilityRule, S as SectionNode, T as TIER_HEIGHT_M, U as UNGROUPED_ID, a as applyHidden, c as computeSections, h as hiddenObjectIds, i as isSectionHidden, s as sectionGeometry } from '../../sections-mLOZrGrI.js';
+import { E as ExpandedSeat } from '../../renderer-IBi9YKWR.js';
+
+/**
+ * THE bowl resolver — whether a floor's stands wrap a centre, and the smooth
+ * radial profile they wrap it with.
+ *
+ * A chart authors sections one at a time, and the 3D scene builder draws them
+ * one at a time, so a venue that is physically ONE continuous bowl renders as
+ * discrete blocks with dark voids between them. This module recovers the fact
+ * the author never states: these stands are rings of one bowl, and the bowl has
+ * a continuous inner edge, outer edge and deck level at every bearing — filled
+ * across the aisles and vomitories that separate the authored sections.
+ *
+ * Pure — no renderer types, no GL — for the same reason `venueStructure.ts` is:
+ * one resolver, consumed by the 3D scene (continuous bowl deck + derived shell)
+ * and by anything added later, so no consumer re-derives "is this a bowl" its
+ * own way. It is measured entirely from SEAT ROWS, never from section outlines:
+ * outlines carry authored margins and decoration, while rows are where the deck
+ * truthfully is (the lesson `surface.ts` already encodes).
+ *
+ * ## Model
+ *
+ * - The CENTRE is what the seating was struck about — the median of per-row
+ *   circle fits when the rows are arcs (`fitCircle`, shared with the concentric
+ *   model in `venueStructure`), else the seat centroid. Never the focal point:
+ *   an end-stage hall's focal is the stage, not the bowl centre.
+ * - Bearings are binned (cw from +y, matching `templateGeom.polar`). Each ring
+ *   of stands contributes, per bin, its innermost/outermost row radius, the
+ *   deck level of each, and a small radial level profile in between.
+ * - Sections cluster into RINGS by radial-interval overlap, so a lower bowl,
+ *   a loge line and an upper tier stay three rings instead of one smeared
+ *   annulus.
+ * - Aisle/vomitory gaps up to {@link GAP_FILL_BINS} bins are interpolated —
+ *   that interpolation IS the continuity this module exists to provide. Larger
+ *   gaps split a ring into open arcs (an end-stage horseshoe keeps its mouth).
+ * - Everything is rejected unless it is genuinely annular: a cinema's or a
+ *   ballroom's seats surround their own centroid with no hole in the middle,
+ *   and must not grow a bowl around themselves.
+ */
+
+/** One authored row (or one level ribbon) as the fit consumes it. */
+interface BowlRowSample {
+    readonly pts: readonly Point[];
+    /** World-metre deck level of this row. */
+    readonly levelM: number;
+}
+interface BowlSectionSamples {
+    readonly sectionId: string;
+    /** The section's resolved rows. Callers pass stands only (no table patches). */
+    readonly rows: readonly BowlRowSample[];
+}
+/** A contiguous covered run of bearing bins within one ring. */
+interface BowlArc {
+    /** First covered bin index. */
+    readonly startBin: number;
+    /** Number of covered bins (may wrap past the bin count). */
+    readonly binCount: number;
+    /** True when the ring is covered at every bearing — a full closed bowl. */
+    readonly closed: boolean;
+    /** Per covered bin, sampled at the bin-centre bearing: */
+    readonly innerR: Float64Array;
+    readonly outerR: Float64Array;
+    readonly frontLevelM: Float64Array;
+    readonly topLevelM: Float64Array;
+    /**
+     * Per covered bin, the radial deck profile: knot radii (ascending) with the
+     * deck level at each. `levelAt` interpolates within these, so a ring holding
+     * two radially-stacked blocks with a cross-aisle keeps its true step instead
+     * of a straight front-to-back chord that could rise above a real deck.
+     */
+    readonly profiles: ReadonlyArray<{
+        rs: readonly number[];
+        ls: readonly number[];
+    }>;
+}
+interface BowlRing {
+    readonly arcs: readonly BowlArc[];
+    readonly sectionIds: readonly string[];
+    /** Median radii, chart units — the ring's identity for callers and tests. */
+    readonly innerRMedian: number;
+    readonly outerRMedian: number;
+}
+interface BowlFit {
+    readonly centre: Point;
+    readonly binCount: number;
+    /** Degrees per bin. */
+    readonly binStepDeg: number;
+    /** Rings ordered inner to outer. */
+    readonly rings: readonly BowlRing[];
+}
+/** Bearing of `p` about `c`, degrees cw from +y in [0, 360) — the inverse of
+ * `templateGeom.polar`. */
+declare function bearingDeg(c: Point, p: Point): number;
+/**
+ * Resolve the continuous bowl profile of one floor's stands, or null when the
+ * floor is not a bowl.
+ *
+ * `sections` should carry only resolved multi-row stands (the caller filters
+ * flats and table patches — they can be ON a bowl floor without being bowl).
+ *
+ * `focal` is the floor's focal point when known. A bowl WRAPS what people look
+ * at; a hall whose fitted "hole" is merely its own cross-aisle (a cinema reads
+ * annular about the walkway between its front and back blocks) has its focal
+ * far outside that hole, and is rejected.
+ */
+declare function fitBowlProfile(sections: readonly BowlSectionSamples[], focal?: Point): BowlFit | null;
+/**
+ * Deck level of `arc` at (bearing, radius), world metres — the radial profile
+ * of the two nearest bins, blended by bearing. Returns the nearest covered
+ * value when the query lies outside the arc's angular span.
+ */
+declare function arcLevelAt(fit: BowlFit, arc: BowlArc, bearing: number, r: number): number;
+
+/**
+ * A section's RAKE FIELD — the scalar "depth" that its seating rises along.
+ *
+ * ## The defect this exists to fix
+ *
+ * Both the eye-height model (`layout.ts`) and the 3D seating surface
+ * (`view3d/scene/surface.ts`) used to raise a seat by its radial distance from
+ * ONE venue focal point. That is only correct when a section's rows are
+ * concentric arcs about that focal.
+ *
+ * Measured on the amphitheatre gallery, whose rows are straight blocks: a single
+ * row's seats span a radial-distance range of 105 chart units on the
+ * centre-facing blocks and 240 on the side blocks. Since height is a function of
+ * that distance, one row's seats landed at DIFFERENT heights — a within-row deck
+ * spread of 2.30 m on the side blocks against 1.05 m on the centre-facing ones.
+ * On screen the rows visibly tilt, and the tilt differs block to block, which is
+ * exactly the left/right asymmetry the owner reported.
+ *
+ * ## Why a per-section AXIS is not enough
+ *
+ * The first attempt fitted one straight rake axis per section by PCA over its row
+ * centroids, and scored it against the radial model. It did not fix the
+ * amphitheatre, because `sec-gall` is a SINGLE section containing six wedge
+ * blocks at six different orientations. No single axis — straight or radial —
+ * fits them all, so the fit correctly fell back to radial and the tilt survived.
+ * Sections containing several blocks are normal, not exotic.
+ *
+ * ## The model that does work
+ *
+ * Depth is defined by the section's OWN ROWS. Each row gets one depth value (the
+ * mean distance of its seats from the focal), and the field at an arbitrary point
+ * is an inverse-distance blend of the nearest rows' depths.
+ *
+ * The properties that matter:
+ *
+ *  - **Exact on a row.** A point on a row has zero distance to it, so it takes
+ *    that row's depth exactly and every seat in the row lands at ONE height.
+ *    The tilt cannot come back, whatever the row's orientation.
+ *  - **Orientation-free.** Straight blocks, arcs, fans, in-the-round and blocks
+ *    at six different angles in one section all work, because nothing is fitted
+ *    to a direction.
+ *  - **Continuous.** It is a field over the plane, not a per-seat lookup. The 3D
+ *    cap is tessellated at points BETWEEN seats and needs a value and a gradient
+ *    there; a per-row lookup would leave the deck undefined between rows and put
+ *    the seats back off the surface they stand on.
+ *
+ * That last point is why quantising per row inside `assignEyeHeights` was tried
+ * and removed: the renderer cannot follow a step function it has no definition
+ * for, and the two models diverging is the trap that made every offset constant
+ * chart-specific.
+ */
+
+/** A resolved row: its seats as an ordered polyline, plus its depth ordinate. */
+interface RakeRowFit {
+    /** The row's seats, ordered along the row. */
+    readonly pts: readonly Point[];
+    /** Mean distance of the row's seats from the focal — what rise is a function of. */
+    readonly depth: number;
+}
+interface SectionRake {
+    readonly kind: 'radial' | 'rows';
+    /** Depth ordinate at a chart-unit point; rise is a function of this. */
+    depthAt(x: number, y: number): number;
+    /** Unit gradient direction of `depthAt` — turns a rake angle into a normal. */
+    gradientAt(x: number, y: number): readonly [number, number];
+    /** Number of rows the field was built from (0 for the radial fallback). */
+    readonly rowCount: number;
+    /**
+     * The section's rows, ORDERED BY DEPTH (front first).
+     *
+     * The deck is built directly from these — one level ribbon per row — rather
+     * than by tessellating `depthAt`. See `deckBands.ts` for why: a section holding
+     * several blocks at different heights has a genuine cliff between them, and no
+     * continuous field can be both level on every row and trackable by refinement.
+     */
+    readonly rows: readonly RakeRowFit[];
+    /** Index into `rows` of the row nearest a point, or -1 when there are none. */
+    nearestRow(x: number, y: number): number;
+}
+/** One row's member points, in any order. */
+interface RakeRow {
+    points: Point[];
+}
+/**
+ * Build a section's rake field from its rows.
+ *
+ * `rows` should be the section's member seats grouped by row. With fewer than two
+ * usable rows there is nothing to build a field from, so the radial model is kept
+ * — which is also how every chart behaved before this, leaving a row-less or
+ * single-row section unchanged.
+ */
+declare function buildSectionRake(rows: RakeRow[], focal: Point): SectionRake;
+
+/**
+ * The seat NUMBER part of a row seat's label (the row prefix is prepended by the
+ * caller). Applies the row's numbering scheme, direction, step, start and label
+ * prefix. Labels only — never geometry. See `RowObject.seatNumbering.scheme`.
+ */
+declare function seatLabelPart(row: RowObject, i: number): string;
+/**
+ * The synthetic row that DISPLAY numbering is computed against.
+ *
+ * A segmented component must number as though it were the whole logical row:
+ * the logical row's total seat count and label, so that scheme, direction,
+ * `endAt` and `center` ranking all resolve across the full span rather than
+ * restarting inside each component. Combined with the component's
+ * `displayOffset`, this is what makes `A-1…A-13` continuous.
+ *
+ * Every surface that renders a display label must go through this rather than
+ * assembling the same object inline — three copies of it are exactly how canvas
+ * and buyer drifted apart.
+ */
+declare function logicalNumberingRow(placement: SegmentedRowPlacement): RowObject;
+/**
+ * The seat's BOOKING IDENTITY. Always physical: the storing row's label and the
+ * physical index within it. A seat-level override wins because it was authored
+ * deliberately.
+ */
+declare function seatInventoryLabel(row: RowObject, physicalIndex: number, override?: SeatOverride): string;
+/**
+ * The seat's HUMAN-FACING label.
+ *
+ * With no `placement` this is the physical label under the row's own display
+ * prefix. With a `placement` the seat numbers against the logical row at its
+ * component's offset — the identical construction buyer expansion uses, so the
+ * author and the buyer can never see different seat numbers.
+ *
+ * A seat-level `displayLabel` override remains the highest-precedence copy.
+ */
+declare function seatDisplayLabel(row: RowObject, physicalIndex: number, placement?: SegmentedRowPlacement, override?: SeatOverride): string;
+
+/**
+ * THE structure resolver — what a chart's seats actually form, geometrically.
+ *
+ * A chart is authored in 2D as sections, rows and seats. Rendering it in 3D needs
+ * a level above that which the author never states: which rows belong to the same
+ * physical STAND, which of them is that stand's front row, and how deep into the
+ * stand each row sits. Every height in the venue follows from those three facts.
+ *
+ * This module resolves them, once, from the authored geometry alone. It is pure —
+ * no renderer types, no GL — so the same structure feeds the 3D surface, the
+ * eye-height model in `layout.ts`, and anything added later (labels, LOD
+ * streaming, per-block camera framing) without any of them re-deriving it. That
+ * matters because re-derivation is this codebase's most expensive bug class:
+ * three surfaces held apart by offsets, and a cap and its seats measured from
+ * different datums, both came from two files computing the same fact differently.
+ *
+ * ## Why blocks, and why depth is measured inside one
+ *
+ * A section is not a stand. The amphitheatre's `sec-gall` is a single section
+ * holding six wedge blocks that wrap the bowl; the arena's tiers are four blocks
+ * each. Height used to be a function of distance from the venue focal, which is
+ * wrong for exactly this reason — the side blocks of a tier sit further from the
+ * focal than the centre blocks, so they were raised as though they were further
+ * back. Measured on `sec-gall`, authored at 6.20 m: its six blocks started at
+ * 6.35, 6.37, 8.18, 8.23, 10.60 and 10.65 m. The side wedges were **4.4 m too
+ * high**, and that is the tilt-and-lift the owner could see.
+ *
+ * Depth is therefore measured WITHIN a block, from that block's own front row:
+ *
+ *     level(row) = section.height + blockDepth(row) · tan(rake)
+ *
+ * so every block of a tier starts at the tier's authored height, and rows rise by
+ * the real spacing between them. A venue whose tier is genuinely flat authors
+ * `rake = 0` and every row lands on the same level — the same model, no special
+ * case, which is what lets one code path serve a stepped bowl and a flat terrace.
+ */
+
+/** A row resolved into its stand. */
+interface ResolvedRow {
+    /** The row's authored id, or a synthetic one for a seat that has none. */
+    id: string;
+    /** The row's seats as an ordered polyline (the shape the deck is built on). */
+    pts: Point[];
+    /** Indices into the input seat array, parallel to nothing — for attribution. */
+    seatIndices: number[];
+    /** Which block (stand) this row belongs to, within its section. */
+    blockId: number;
+    /** 0 for the block's front row, then 1, 2, … going back. */
+    ordinal: number;
+    /**
+     * Distance back from the block's FRONT row, chart units, accumulated over the
+     * real gaps between consecutive rows.
+     *
+     * Not the ordinal times a nominal pitch: a stand with an aisle break or a
+     * widening row gap should rise over that gap, and accumulating the measured
+     * spacing keeps the drawn deck on the seats. Not distance from the venue focal
+     * either — that is the defect described above.
+     */
+    blockDepth: number;
+    /** Mean distance of the row's seats from the venue focal (front-row ordering). */
+    focalDistance: number;
+}
+interface ResolvedSection {
+    sectionId: string;
+    /** Rows ordered by block, then front-to-back within the block. */
+    rows: ResolvedRow[];
+    /** Number of distinct blocks found. */
+    blockCount: number;
+}
+/** Perpendicular distance from a point to a polyline, chart units. */
+declare function distanceToPolyline(pts: readonly Point[], x: number, y: number): number;
+/**
+ * Least-squares circle through a set of points (Kåsa fit), or null if degenerate.
+ *
+ * Used to find the centre a section's rows were struck about, which is NOT the
+ * chart's focal point. The amphitheatre makes this concrete: its rows are arcs
+ * about a centre `C`, while `focalPoint` is the stage at {0, 75}. Measuring depth
+ * from the focal therefore varied ALONG each arc — the original row tilt — and
+ * made concentric rows look radial to every heuristic downstream.
+ *
+ * The focal is where the audience LOOKS. The row centre is what the seating was
+ * drawn around. Conflating them is the mistake underneath several of the defects
+ * in this file's history.
+ */
+declare function fitCircle(pts: readonly Point[]): {
+    cx: number;
+    cy: number;
+} | null;
+/**
+ * Resolve one section's seats into blocks and depth-ordered rows.
+ *
+ * `seatIndices` are indices into the caller's own seat array, so a caller can
+ * attribute the result back without this module knowing what it is attributing to.
+ */
+declare function resolveSection(sectionId: string, seats: readonly ExpandedSeat[], seatIndices: readonly number[], focal: Point): ResolvedSection;
+
+export { type BowlArc, type BowlFit, type BowlRing, type BowlRowSample, type BowlSectionSamples, type RakeRow, type RakeRowFit, type ResolvedRow, type ResolvedSection, type SectionRake, arcLevelAt, bearingDeg, buildSectionRake, distanceToPolyline, fitBowlProfile, fitCircle, logicalNumberingRow, resolveSection, seatDisplayLabel, seatInventoryLabel, seatLabelPart };

package/dist/core/sections/index.js

@@ -0,0 +1 @@
+import{a as D}from"../../chunk-EQM4FFN5.js";import{a as E,b as F,c as G,d as H}from"../../chunk-55NOSZK5.js";import{j as y,k as z,l as A,m as B,n as C}from"../../chunk-AQKYUJBX.js";import{A as e,B as f,C as m,D as p,E as t,F as x,G as a,H as b,M as c,N as d,O as g,P as h,Q as i,R as j,S as k,T as l,U as n,X as q,fa as s,ga as u,ha as v,ia as w,y as o,z as r}from"../../chunk-VDZ24QVV.js";export{p as DEFAULT_SECTION_CORNER_SMOOTHING,x as MAX_EDGE_SAGITTA_RATIO,q as TIER_HEIGHT_M,y as UNGROUPED_ID,C as applyHidden,H as arcLevelAt,F as bearingDeg,E as buildSectionRake,z as computeSections,u as distanceToPolyline,G as fitBowlProfile,v as fitCircle,B as hiddenObjectIds,d as indexLabel,A as isSectionHidden,k as logicalNumberingRow,i as relabelRows,w as resolveSection,b as reverseSectionOutlinePath,e as sampleSectionOutlinePath,D as seatConfidenceDisclosure,n as seatDisplayLabel,l as seatInventoryLabel,j as seatLabelPart,t as sectionCornerSmoothingPath,s as sectionGeometry,a as sectionOutlinePathFrom,o as sectionPathSegmentEnd,c as toBijectiveBase,g as toLetters,h as toRoman,m as transformSectionOutlinePath,f as translateSectionOutlinePath,r as validSectionOutlinePath};