@seatlayer/core 0.31.0 → 0.32.0

package/dist/{chunk-FGS67GT3.js → chunk-MGC5BVAD.js}

@@ -27,6 +27,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 = [
@@ -152,6 +161,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 t = 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 + t * dx), p.y - (a.y + t * 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) {
@@ -860,38 +1010,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 bounds = { minX: Math.min(...xs), maxX: Math.max(...xs), minY: Math.min(...ys), maxY: Math.max(...ys) };
-  const centroid = polygonCentroid(outer);
-  if (pointInPolygonWithHoles(centroid, outer, holes)) return centroid;
-  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: bounds.minX + (bounds.maxX - bounds.minX) * column / 24,
-        y: bounds.minY + (bounds.maxY - bounds.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 t = Math.max(0, Math.min(1, projection));
-        return Math.hypot(point.x - (start.x + t * dx), point.y - (start.y + t * 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 };
@@ -1214,11 +1333,15 @@ export {
   accessibilityMeta,
   ACCESSIBILITY_RING_COLOR,
   accessibilityRingColor,
+  SEAT_COMMERCIAL_MARKS,
+  seatCommercialMeta,
   LABEL_STYLE_MIN_SIZE,
   LABEL_STYLE_MAX_SIZE,
   SURROUNDINGS_SHAPE_ROLES,
   layerOf,
   CHART_STORAGE_KEY,
+  distanceToRings,
+  polygonNetArea,
   METRES_PER_CHART_UNIT,
   CHART_UNITS_PER_METRE,
   TIER_HEIGHT_M,
@@ -1249,4 +1372,4 @@ export {
   expandChart,
   chartBounds
 };
-//# sourceMappingURL=chunk-FGS67GT3.js.map
+//# sourceMappingURL=chunk-MGC5BVAD.js.map