@seatlayer/core 0.30.1 → 0.32.0

package/dist/index.cjs

@@ -218,6 +218,7 @@ __export(index_exports, {
   MAX_GA_CAPACITY: () => MAX_GA_CAPACITY,
   PickerController: () => PickerController,
   RENDERED_QUALITY_REPORT_VERSION: () => RENDERED_QUALITY_REPORT_VERSION,
+  SEAT_COMMERCIAL_MARKS: () => SEAT_COMMERCIAL_MARKS,
   SUPPORTED_LOCALES: () => SUPPORTED_LOCALES,
   SURROUNDINGS_SHAPE_ROLES: () => SURROUNDINGS_SHAPE_ROLES,
   SeatmapRenderer: () => SeatmapRenderer,
@@ -263,6 +264,7 @@ __export(index_exports, {
   resolveLocale: () => resolveLocale,
   rowInventoryCount: () => rowInventoryCount,
   rowSeatPositions: () => rowSeatPositions,
+  seatCommercialMeta: () => seatCommercialMeta,
   seatLabelPart: () => seatLabelPart,
   sectionGeometry: () => sectionGeometry,
   setLocale: () => setLocale,
@@ -306,6 +308,15 @@ function accessibilityRingColor(types) {
   const primary = types?.[0];
   return primary && ACCESSIBILITY_RING_COLOR[primary] || "#3b82f6";
 }
+var SEAT_COMMERCIAL_MARKS = [
+  { key: "obstructedView", label: "Obstructed view", short: "Obstructed", icon: "\u26D4" },
+  { key: "restrictedView", label: "Restricted view", short: "Restricted", icon: "\u{1F441}" },
+  { key: "premium", label: "Premium seat", short: "Premium", icon: "\u2605" }
+];
+var SEAT_COMMERCIAL_LABEL = new Map(SEAT_COMMERCIAL_MARKS.map((mark) => [mark.key, mark]));
+function seatCommercialMeta(key) {
+  return SEAT_COMMERCIAL_LABEL.get(key);
+}
 var LABEL_STYLE_MIN_SIZE = 8;
 var LABEL_STYLE_MAX_SIZE = 24;
 var SURROUNDINGS_SHAPE_ROLES = [
@@ -387,6 +398,147 @@ function distributeAlongCubic(path, count, resolution = 192) {
   return output;
 }
 
+// src/core/polygonAnchor.ts
+var MAX_CELLS = 4e3;
+function distanceToSegment(p, a, b) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const denominator = dx * dx + dy * dy;
+  const t2 = denominator ? Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / denominator)) : 0;
+  return Math.hypot(p.x - (a.x + t2 * dx), p.y - (a.y + t2 * dy));
+}
+function distanceToRings(p, rings) {
+  let best = Infinity;
+  for (const ring of rings) {
+    if (ring.length < 2) continue;
+    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+      const d = distanceToSegment(p, ring[j], ring[i]);
+      if (d < best) best = d;
+    }
+  }
+  return best;
+}
+function inRing(p, ring) {
+  let inside = false;
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    const xi = ring[i].x;
+    const yi = ring[i].y;
+    const xj = ring[j].x;
+    const yj = ring[j].y;
+    const hit = yi > p.y !== yj > p.y && p.x < (xj - xi) * (p.y - yi) / (yj - yi) + xi;
+    if (hit) inside = !inside;
+  }
+  return inside;
+}
+function signedDistance(p, outer, holes) {
+  const inside = inRing(p, outer) && !holes.some((hole) => inRing(p, hole));
+  const distance = distanceToRings(p, [outer, ...holes]);
+  return inside ? distance : -distance;
+}
+function cellAt(x, y, h, outer, holes) {
+  const d = signedDistance({ x, y }, outer, holes);
+  return { x, y, h, d, max: d + h * Math.SQRT2 };
+}
+var CellQueue = class {
+  constructor() {
+    this.items = [];
+  }
+  get size() {
+    return this.items.length;
+  }
+  push(cell) {
+    const items = this.items;
+    items.push(cell);
+    let index = items.length - 1;
+    while (index > 0) {
+      const parent = index - 1 >> 1;
+      if (items[parent].max >= items[index].max) break;
+      [items[parent], items[index]] = [items[index], items[parent]];
+      index = parent;
+    }
+  }
+  pop() {
+    const items = this.items;
+    const top = items[0];
+    const last = items.pop();
+    if (items.length && last) {
+      items[0] = last;
+      let index = 0;
+      for (; ; ) {
+        const left = index * 2 + 1;
+        const right = left + 1;
+        let best = index;
+        if (left < items.length && items[left].max > items[best].max) best = left;
+        if (right < items.length && items[right].max > items[best].max) best = right;
+        if (best === index) break;
+        [items[best], items[index]] = [items[index], items[best]];
+        index = best;
+      }
+    }
+    return top;
+  }
+};
+function polygonArea(ring) {
+  if (ring.length < 3) return 0;
+  let sum = 0;
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    sum += (ring[j].x + ring[i].x) * (ring[j].y - ring[i].y);
+  }
+  return Math.abs(sum) / 2;
+}
+function polygonNetArea(outer, holes) {
+  return Math.max(0, polygonArea(outer) - (holes ?? []).reduce((total, hole) => total + polygonArea(hole), 0));
+}
+function polygonInscribedAnchor(outer, holes) {
+  const rings = holes ?? [];
+  if (!outer.length) return { point: { x: 0, y: 0 }, radius: 0 };
+  if (outer.length < 3) {
+    const x = outer.reduce((total, p) => total + p.x, 0) / outer.length;
+    const y = outer.reduce((total, p) => total + p.y, 0) / outer.length;
+    return { point: { x, y }, radius: 0 };
+  }
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const p of outer) {
+    if (p.x < minX) minX = p.x;
+    if (p.y < minY) minY = p.y;
+    if (p.x > maxX) maxX = p.x;
+    if (p.y > maxY) maxY = p.y;
+  }
+  const width = maxX - minX;
+  const height = maxY - minY;
+  const cellSize = Math.min(width, height);
+  if (!(cellSize > 0)) {
+    return { point: { x: (minX + maxX) / 2, y: (minY + maxY) / 2 }, radius: 0 };
+  }
+  const precision = Math.max(width, height) / 150;
+  const queue = new CellQueue();
+  let h = cellSize / 2;
+  for (let x = minX; x < maxX; x += cellSize) {
+    for (let y = minY; y < maxY; y += cellSize) {
+      queue.push(cellAt(x + h, y + h, h, outer, rings));
+    }
+  }
+  let best = cellAt(minX + width / 2, minY + height / 2, 0, outer, rings);
+  let explored = 0;
+  while (queue.size) {
+    const cell = queue.pop();
+    if (!cell) break;
+    if (cell.d > best.d) best = cell;
+    if (cell.max - best.d <= precision) continue;
+    if (explored >= MAX_CELLS) continue;
+    explored += 1;
+    h = cell.h / 2;
+    queue.push(cellAt(cell.x - h, cell.y - h, h, outer, rings));
+    queue.push(cellAt(cell.x + h, cell.y - h, h, outer, rings));
+    queue.push(cellAt(cell.x - h, cell.y + h, h, outer, rings));
+    queue.push(cellAt(cell.x + h, cell.y + h, h, outer, rings));
+  }
+  return { point: { x: best.x, y: best.y }, radius: Math.max(0, best.d) };
+}
+
 // src/core/sectionPath.ts
 var TAU = Math.PI * 2;
 function translateSectionOutlinePath(path, dx, dy) {
@@ -1139,38 +1291,7 @@ function pointInPolygonWithHoles(p, outer, holes) {
   return pointInPolygon(p, outer) && !(holes ?? []).some((hole) => pointInPolygon(p, hole) || pointOnPolygonBoundary(p, hole));
 }
 function polygonLabelPoint(outer, holes) {
-  if (!outer.length) return { x: 0, y: 0 };
-  const xs = outer.map((point) => point.x);
-  const ys = outer.map((point) => point.y);
-  const bounds2 = { minX: Math.min(...xs), maxX: Math.max(...xs), minY: Math.min(...ys), maxY: Math.max(...ys) };
-  const centroid2 = polygonCentroid(outer);
-  if (pointInPolygonWithHoles(centroid2, outer, holes)) return centroid2;
-  let best = outer[0];
-  let bestScore = -Infinity;
-  const rings = [outer, ...holes ?? []];
-  for (let row = 1; row < 24; row += 1) {
-    for (let column = 1; column < 24; column += 1) {
-      const point = {
-        x: bounds2.minX + (bounds2.maxX - bounds2.minX) * column / 24,
-        y: bounds2.minY + (bounds2.maxY - bounds2.minY) * row / 24
-      };
-      if (!pointInPolygonWithHoles(point, outer, holes)) continue;
-      const score = Math.min(...rings.flatMap((ring) => ring.map((start, index) => {
-        const end = ring[(index + 1) % ring.length];
-        const dx = end.x - start.x;
-        const dy = end.y - start.y;
-        const denominator = dx * dx + dy * dy;
-        const projection = denominator ? ((point.x - start.x) * dx + (point.y - start.y) * dy) / denominator : 0;
-        const t2 = Math.max(0, Math.min(1, projection));
-        return Math.hypot(point.x - (start.x + t2 * dx), point.y - (start.y + t2 * dy));
-      })));
-      if (score > bestScore) {
-        best = point;
-        bestScore = score;
-      }
-    }
-  }
-  return best;
+  return polygonInscribedAnchor(outer, holes).point;
 }
 function polygonCentroid(pts) {
   if (!pts.length) return { x: 0, y: 0 };
@@ -2840,7 +2961,7 @@ var ISO_SQUASH = 0.58;
 var ISO_TWEEN_MS = 320;
 var CAMERA_GLIDE_MS = 650;
 var BLOCK_FILL_ALPHA = 1;
-var SECTION_STROKE_PX = 2;
+var SECTION_STROKE_PX = 1;
 var LIGHT_OVERVIEW_SECTION_FILL = "#e5e7eb";
 var LIGHT_OVERVIEW_SECTION_STROKE = "#c7cbd1";
 var LIGHT_OVERVIEW_SECTION_INK = "#595f69";
@@ -2853,6 +2974,7 @@ var DARK_OVERVIEW_FOCAL_FILL = "#374151";
 var DARK_OVERVIEW_FOCAL_STROKE = "#64748b";
 var SECTION_LABEL_PX = 20;
 var MIN_SECTION_LABEL_PX = 12;
+var SECTION_LABEL_SHRINK_STEPS = [0.85, 0.72, 0.62];
 var ZONE_LABEL_PX = 18;
 var ZONE_SUB_PX = 12;
 var HIERARCHY_PILL_BACKGROUND = "#111827";
@@ -3027,7 +3149,6 @@ function rotatedRectFitsPolygon(center, width, height, rotation, outer, holes) {
 }
 function polygonLabelCandidates(outer, holes, preferred) {
   const bounds2 = polyBounds(outer);
-  const centre = { x: bounds2.x + bounds2.width / 2, y: bounds2.y + bounds2.height / 2 };
   const points = [preferred];
   for (let row = 1; row < 12; row += 1) {
     for (let column = 1; column < 12; column += 1) {
@@ -3038,7 +3159,8 @@ function polygonLabelCandidates(outer, holes, preferred) {
       if (pointInPolygonWithHoles(point, outer, holes)) points.push(point);
     }
   }
-  return points.sort((left, right) => Math.hypot(left.x - centre.x, left.y - centre.y) - Math.hypot(right.x - centre.x, right.y - centre.y)).filter((point, index, all) => index === all.findIndex((other) => Math.abs(other.x - point.x) < 1e-6 && Math.abs(other.y - point.y) < 1e-6));
+  const rings = [outer, ...holes];
+  return points.map((point) => ({ point, room: distanceToRings(point, rings) })).sort((left, right) => right.room - left.room).map((entry) => entry.point).filter((point, index, all) => index === all.findIndex((other) => Math.abs(other.x - point.x) < 1e-6 && Math.abs(other.y - point.y) < 1e-6));
 }
 function roundedPolygonSubpath(context, points, radius) {
   const n = points.length;
@@ -5880,7 +6002,7 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     const outlineTint = obj.color ?? this.zoneColor.get(obj.zone ?? "") ?? "#3a4358";
     const outlinePoly = polygonWithHolesShape(obj.outline, obj.holes, {
       stroke: rgba(outlineTint, 0.5),
-      strokeWidth: 1.75,
+      strokeWidth: 1,
       fill: rgba(outlineTint, 0.08),
       listening: false
     }, obj.outlinePath);
@@ -5935,6 +6057,7 @@ var _SeatmapRenderer = class _SeatmapRenderer {
       holes: obj.holes ?? [],
       centroid: centroid2,
       labelAnchors: polygonLabelCandidates(obj.outline, obj.holes ?? [], centroid2),
+      labelArea: polygonNetArea(obj.outline, obj.holes),
       zone: obj.zone,
       memberIds,
       total: memberIds.length,
@@ -6186,8 +6309,16 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     }
   }
   /**
-   * Keep transitional zone pills from covering section names. Section names
-   * are already proven inside disjoint shells, so they must not cull each other.
+   * Keep transitional zone pills from covering section names, and keep section
+   * names off each other.
+   *
+   * This used to assume section labels "do not collide by construction",
+   * because each is proven to fit inside its own shell. That holds only while
+   * shells are disjoint. Hand-traced and imported plans routinely produce
+   * shells that touch or overlap slightly along a shared edge, and a label
+   * fitted into one can then land under its neighbour's — which is exactly the
+   * unreadable smear a 36-section arena showed. Section labels now block each
+   * other too, largest shell first so the big stands keep their names.
    */
   decollideRungLabels(sx) {
     const GAP = 4;
@@ -6213,20 +6344,39 @@ var _SeatmapRenderer = class _SeatmapRenderer {
       }
     }
     for (const sec of this.sections) {
-      if (sec.nameLabel.opacity() > 0.05) cands.push({ node: sec.nameLabel, tier: 1, section: true, box: boxOf(sec.nameLabel) });
+      if (sec.nameLabel.opacity() > 0.05) {
+        cands.push({ node: sec.nameLabel, tier: 1, section: true, area: sec.labelArea, box: boxOf(sec.nameLabel) });
+      }
     }
     if (cands.length < 2) return;
-    cands.sort((a, b) => a.tier - b.tier || a.box.y - b.box.y || a.box.x - b.box.x);
+    cands.sort((a, b) => a.tier - b.tier || (b.area ?? 0) - (a.area ?? 0) || a.box.y - b.box.y || a.box.x - b.box.x);
     const kept = [];
     const collides = (b) => kept.some(
       (k) => b.x < k.x + k.w + GAP && k.x < b.x + b.w + GAP && b.y < k.y + k.h + GAP && k.y < b.y + b.h + GAP
     );
     for (const c of cands) {
-      if (collides(c.box)) {
-        c.node.opacity(0);
-      } else if (!c.section) {
+      if (!collides(c.box)) {
         kept.push(c.box);
+        continue;
+      }
+      let placed = false;
+      if (c.section) {
+        const fontSize = c.node.fontSize();
+        const y = c.node.y();
+        for (const factor of SECTION_LABEL_SHRINK_STEPS) {
+          const candidate = fontSize * factor;
+          if (candidate * sx < MIN_SECTION_LABEL_PX) break;
+          this.sizeLabel(c.node, candidate, y);
+          const box = boxOf(c.node);
+          if (!collides(box)) {
+            kept.push(box);
+            placed = true;
+            break;
+          }
+        }
+        if (!placed) this.sizeLabel(c.node, fontSize, y);
       }
+      if (!placed) c.node.opacity(0);
     }
   }
   /** Set a centred label's world fontSize (for a target screen px) and re-anchor it. */
@@ -6847,7 +6997,20 @@ var _SeatmapRenderer = class _SeatmapRenderer {
         visible,
         renderedFontPx,
         fill: typeof fill === "string" ? fill : "",
-        ink: typeof ink === "string" ? ink : this.theme.seatLabelColor ?? DEF_SEAT_LABEL,
+        // When no label node exists (the seat is unlabelled at this zoom), fall
+        // back to the ink this seat WOULD be painted with — the same expression
+        // the seat-level evidence below uses — not to the raw theme default.
+        //
+        // The old fallback reported `DEF_SEAT_LABEL` (#0b1220) regardless of the
+        // seat's paint, so a held seat with no label read as dark ink on
+        // HELD_FILL (#6b7280) = 3.87:1 and a booked one as 1.82:1 against
+        // TAKEN_FILL. That is a contrast violation the renderer never commits:
+        // `seatLabelInk` runs every real label through `stateAwareBookableLabelInk`,
+        // which returns #ffffff for both of those fills. A catalog visual audit
+        // read this fallback as though it were painted and reported a
+        // bookable-state contrast failure on 46 of 50 templates that does not
+        // exist on screen.
+        ink: typeof ink === "string" ? ink : shape ? this.seatLabelInk(seat, shape) : this.seatPreferredLabelInk(seat),
         opacity: rounded(opacity),
         ...accessGlyph ? {
           accessibilityMarker: {
@@ -10310,6 +10473,7 @@ async function loadLocale(code) {
   MAX_GA_CAPACITY,
   PickerController,
   RENDERED_QUALITY_REPORT_VERSION,
+  SEAT_COMMERCIAL_MARKS,
   SUPPORTED_LOCALES,
   SURROUNDINGS_SHAPE_ROLES,
   SeatmapRenderer,
@@ -10355,6 +10519,7 @@ async function loadLocale(code) {
   resolveLocale,
   rowInventoryCount,
   rowSeatPositions,
+  seatCommercialMeta,
   seatLabelPart,
   sectionGeometry,
   setLocale,