@seatlayer/core 0.22.0 → 0.23.0

package/dist/index.d.cts

@@ -2067,8 +2067,28 @@ declare class PickerController {
         tierId?: string | null;
         ttlMs?: number;
     }): Promise<HoldInfo | null>;
-    /** Server-picks `qty` best free seats and holds them atomically. Throws on failure. */
-    bestAvailable(qty: number, categoryKey?: string): Promise<HoldInfo | null>;
+    /** True when any seat on the visible chart carries the `premium` commercial
+     *  flag — gates the buyer widget's "★ Best seats" premium quick-pick (chip is
+     *  present-only, exactly like the accessibility filter chips). */
+    hasPremiumSeats(): boolean;
+    /**
+     * Client-side premium pre-pass: find the best contiguous block of `qty`
+     * PREMIUM-flagged free seats (orphan-avoiding, closest to the focal point)
+     * using the local seat geometry + live availability, mirroring the server's
+     * held-back exclusion via the visible (hidden-stripped) chart and current
+     * seat status. Returns a FULL premium block of `qty`, or null when none
+     * exists (the caller then falls back to the normal server pick).
+     */
+    private pickPremiumBlock;
+    /**
+     * Server-picks `qty` best free seats and holds them atomically. Throws on
+     * failure. With `preferPremium`, first tries to hold the best PREMIUM block
+     * locally; when none matches the requested quantity it falls back to the
+     * normal server pick (the widget surfaces a subtle note on that fallback).
+     */
+    bestAvailable(qty: number, categoryKey?: string, opts?: {
+        preferPremium?: boolean;
+    }): Promise<HoldInfo | null>;
     /**
      * Complete a booking. Requires a transport that supports book() (the SDK
      * deliberately does not). `bookingRef` MUST be a real reference from the caller.

package/dist/index.d.ts

@@ -2067,8 +2067,28 @@ declare class PickerController {
         tierId?: string | null;
         ttlMs?: number;
     }): Promise<HoldInfo | null>;
-    /** Server-picks `qty` best free seats and holds them atomically. Throws on failure. */
-    bestAvailable(qty: number, categoryKey?: string): Promise<HoldInfo | null>;
+    /** True when any seat on the visible chart carries the `premium` commercial
+     *  flag — gates the buyer widget's "★ Best seats" premium quick-pick (chip is
+     *  present-only, exactly like the accessibility filter chips). */
+    hasPremiumSeats(): boolean;
+    /**
+     * Client-side premium pre-pass: find the best contiguous block of `qty`
+     * PREMIUM-flagged free seats (orphan-avoiding, closest to the focal point)
+     * using the local seat geometry + live availability, mirroring the server's
+     * held-back exclusion via the visible (hidden-stripped) chart and current
+     * seat status. Returns a FULL premium block of `qty`, or null when none
+     * exists (the caller then falls back to the normal server pick).
+     */
+    private pickPremiumBlock;
+    /**
+     * Server-picks `qty` best free seats and holds them atomically. Throws on
+     * failure. With `preferPremium`, first tries to hold the best PREMIUM block
+     * locally; when none matches the requested quantity it falls back to the
+     * normal server pick (the widget surfaces a subtle note on that fallback).
+     */
+    bestAvailable(qty: number, categoryKey?: string, opts?: {
+        preferPremium?: boolean;
+    }): Promise<HoldInfo | null>;
     /**
      * Complete a booking. Requires a transport that supports book() (the SDK
      * deliberately does not). `bookingRef` MUST be a real reference from the caller.

package/dist/index.js

@@ -323,8 +323,8 @@ function polygonLabelPoint(outer, holes) {
   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;
+  const centroid2 = polygonCentroid(outer);
+  if (pointInPolygonWithHoles(centroid2, outer, holes)) return centroid2;
   let best = outer[0];
   let bestScore = -Infinity;
   const rings = [outer, ...holes ?? []];
@@ -810,7 +810,9 @@ var en = {
   "picker.restrictedView": "Restricted view",
   "picker.obstructedView": "Obstructed view",
   "picker.premiumSeat": "Premium seat",
-  "picker.hideLimitedView": "Hide limited-view seats"
+  "picker.hideLimitedView": "Hide limited-view seats",
+  "picker.bestSeatsPremium": "Best seats",
+  "picker.premiumFallbackNote": "No premium block of {count} \u2014 showing best overall"
 };
 
 // src/i18n/index.ts
@@ -3016,7 +3018,7 @@ var _SeatmapRenderer = class _SeatmapRenderer {
    * Membership and category mix are still precomputed for the detailed state.
    */
   renderSection(obj) {
-    const centroid = polygonLabelPoint(obj.outline, obj.holes);
+    const centroid2 = polygonLabelPoint(obj.outline, obj.holes);
     const palette = overviewPalette(this.canvasBackground);
     const memberIds = [];
     const catCounts = /* @__PURE__ */ new Map();
@@ -3078,8 +3080,8 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     const preferredInk = labelStyle?.color ?? palette.sectionInk;
     const labelScale = (labelStyle?.size ?? 18) / 18;
     const nameLabel = new Text({
-      x: obj.labelPresentation?.position?.x ?? centroid.x,
-      y: obj.labelPresentation?.position?.y ?? centroid.y,
+      x: obj.labelPresentation?.position?.x ?? centroid2.x,
+      y: obj.labelPresentation?.position?.y ?? centroid2.y,
       text: obj.displayLabel ?? obj.label,
       rotation: obj.labelPresentation?.rotation ?? 0,
       visible: obj.labelPresentation?.visible !== false,
@@ -3094,8 +3096,8 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     nameLabel.offsetY(nameLabel.height() / 2);
     bgTarget.add(nameLabel);
     const subLabel = new Text({
-      x: centroid.x,
-      y: centroid.y,
+      x: centroid2.x,
+      y: centroid2.y,
       text: t("map.seatsLeft", { count: free }),
       fontSize: 12,
       fontStyle: "700",
@@ -3114,8 +3116,8 @@ var _SeatmapRenderer = class _SeatmapRenderer {
       outline: obj.outline,
       ...obj.outlinePath ? { outlinePath: obj.outlinePath } : {},
       holes: obj.holes ?? [],
-      centroid,
-      labelAnchors: polygonLabelCandidates(obj.outline, obj.holes ?? [], centroid),
+      centroid: centroid2,
+      labelAnchors: polygonLabelCandidates(obj.outline, obj.holes ?? [], centroid2),
       zone: obj.zone,
       memberIds,
       total: memberIds.length,
@@ -4475,6 +4477,103 @@ function strandedSingles(seats, statusOf, selectedIds) {
   return out;
 }
 
+// src/core/bestAvailable.ts
+function seatIndex2(seat, fallback) {
+  const i = seat.id.lastIndexOf(":");
+  if (i < 0) return fallback;
+  const n = Number(seat.id.slice(i + 1));
+  return Number.isFinite(n) ? n : fallback;
+}
+function dist2(a, b) {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  return dx * dx + dy * dy;
+}
+function centroid(seats) {
+  let x = 0;
+  let y = 0;
+  for (const s of seats) {
+    x += s.x;
+    y += s.y;
+  }
+  return { x: x / seats.length, y: y / seats.length };
+}
+function isPremium(seat) {
+  return seat.commercial?.premium === true;
+}
+function pickBestAvailable(seats, available, opts) {
+  const qty = Math.floor(opts.qty);
+  if (!Number.isFinite(qty) || qty <= 0) return { labels: [], reason: "sold_out" };
+  const { categoryKey, focal, preferPremium } = opts;
+  const rows = /* @__PURE__ */ new Map();
+  const eligibleAll = [];
+  seats.forEach((seat, i) => {
+    const elig = available.has(seat.label) && (!categoryKey || seat.categoryKey === categoryKey);
+    let arr = rows.get(seat.rowId);
+    if (!arr) {
+      arr = [];
+      rows.set(seat.rowId, arr);
+    }
+    arr.push({ seat, index: seatIndex2(seat, i), elig });
+    if (elig) eligibleAll.push(seat);
+  });
+  if (eligibleAll.length === 0) return { labels: [], reason: "sold_out" };
+  let best = null;
+  const better = (c) => {
+    if (!best) return true;
+    if (preferPremium && c.nonPremium !== best.nonPremium) return c.nonPremium < best.nonPremium;
+    if (c.orphan !== best.orphan) return c.orphan < best.orphan;
+    if (c.d2 !== best.d2) return c.d2 < best.d2;
+    const r = c.rowId.localeCompare(best.rowId);
+    if (r !== 0) return r < 0;
+    return c.startIndex < best.startIndex;
+  };
+  for (const [rowId, slotsUnsorted] of rows) {
+    const slots = [...slotsUnsorted].sort((a, b) => a.index - b.index);
+    let i = 0;
+    while (i < slots.length) {
+      if (!slots[i].elig) {
+        i++;
+        continue;
+      }
+      let j = i;
+      while (j < slots.length && slots[j].elig) j++;
+      const segLen = j - i;
+      for (let p = 0; p + qty <= segLen; p++) {
+        const leftRem = p;
+        const rightRem = segLen - (p + qty);
+        const orphan = leftRem === 1 || rightRem === 1 ? 1 : 0;
+        const runSeats = slots.slice(i + p, i + p + qty).map((s) => s.seat);
+        const c = {
+          labels: runSeats.map((s) => s.label),
+          seats: runSeats,
+          rowId,
+          startIndex: slots[i + p].index,
+          orphan,
+          nonPremium: preferPremium ? runSeats.reduce((n, s) => n + (isPremium(s) ? 0 : 1), 0) : 0,
+          d2: dist2(centroid(runSeats), focal)
+        };
+        if (better(c)) best = c;
+      }
+      i = j;
+    }
+  }
+  if (best) return { labels: best.labels };
+  if (eligibleAll.length < qty) return { labels: [], reason: "not_enough_together" };
+  const ranked = eligibleAll.map((seat, i) => ({ seat, i, d2: dist2(seat, focal) })).sort((a, b) => {
+    if (preferPremium) {
+      const pa = isPremium(a.seat) ? 0 : 1;
+      const pb = isPremium(b.seat) ? 0 : 1;
+      if (pa !== pb) return pa - pb;
+    }
+    if (a.d2 !== b.d2) return a.d2 - b.d2;
+    const r = a.seat.rowId.localeCompare(b.seat.rowId);
+    if (r !== 0) return r;
+    return seatIndex2(a.seat, a.i) - seatIndex2(b.seat, b.i);
+  });
+  return { labels: ranked.slice(0, qty).map((r) => r.seat.label) };
+}
+
 // src/picker/PickerController.ts
 var DEFAULT_MAX_SELECTION = 10;
 var MAX_BACKOFF_MS = 15e3;
@@ -4826,10 +4925,77 @@ var PickerController = class {
     this.setHold({ holdId: result.holdId, labels: combined.map((s) => s.label), expiresAt: result.expiresAt, items: result.items });
     return this.hold_;
   }
-  /** Server-picks `qty` best free seats and holds them atomically. Throws on failure. */
-  async bestAvailable(qty, categoryKey) {
+  /** True when any seat on the visible chart carries the `premium` commercial
+   *  flag — gates the buyer widget's "★ Best seats" premium quick-pick (chip is
+   *  present-only, exactly like the accessibility filter chips). */
+  hasPremiumSeats() {
+    for (const seat of this.labelToSeat.values()) {
+      if (seat.commercial?.premium) return true;
+    }
+    return false;
+  }
+  /**
+   * Client-side premium pre-pass: find the best contiguous block of `qty`
+   * PREMIUM-flagged free seats (orphan-avoiding, closest to the focal point)
+   * using the local seat geometry + live availability, mirroring the server's
+   * held-back exclusion via the visible (hidden-stripped) chart and current
+   * seat status. Returns a FULL premium block of `qty`, or null when none
+   * exists (the caller then falls back to the normal server pick).
+   */
+  pickPremiumBlock(qty, categoryKey) {
+    const doc = this.visibleDoc();
+    if (!doc?.objects?.length) return null;
+    const focal = doc.focalPoint ?? { x: 0, y: 0 };
+    const seats = expandChart(doc);
+    const held = new Set(this.hold_?.labels ?? []);
+    const available = /* @__PURE__ */ new Set();
+    for (const seat of seats) {
+      if (held.has(seat.label)) continue;
+      const id = this.labelToId.get(seat.label);
+      const status = id ? this.getStatus(id) : void 0;
+      if ((status ?? "free") === "free") available.add(seat.label);
+    }
+    const pick = pickBestAvailable(seats, available, { qty, categoryKey, focal, preferPremium: true });
+    if (pick.labels.length !== qty) return null;
+    const allPremium = pick.labels.every((l) => this.labelToSeat.get(l)?.commercial?.premium);
+    return allPremium ? [...pick.labels] : null;
+  }
+  /**
+   * Server-picks `qty` best free seats and holds them atomically. Throws on
+   * failure. With `preferPremium`, first tries to hold the best PREMIUM block
+   * locally; when none matches the requested quantity it falls back to the
+   * normal server pick (the widget surfaces a subtle note on that fallback).
+   */
+  async bestAvailable(qty, categoryKey, opts = {}) {
     const r = this.renderer;
     if (!r) return null;
+    if (opts.preferPremium) {
+      const block = this.pickPremiumBlock(qty, categoryKey);
+      if (block) {
+        if (this.hold_ && !await this.release()) return null;
+        try {
+          const selection = block.map((label) => {
+            const seat = this.labelToSeat.get(label);
+            const resolved = seat ? this.toSeat(seat) : null;
+            return { label, ...resolved?.tierId ? { tierId: resolved.tierId } : {} };
+          });
+          const result = await this.api.hold(this.key, selection);
+          r.clearSelection();
+          const ids = block.map((l) => this.labelToId.get(l)).filter((v) => !!v);
+          if (ids.length) r.setStatus(ids, "held");
+          this.setHold({ holdId: result.holdId, labels: [...block], expiresAt: result.expiresAt, items: result.items });
+          const seats = block.map((l) => this.labelToSeat.get(l)).filter((s) => !!s).map((s) => this.toSeat(s));
+          this.opts.onSelectionChange?.(seats);
+          return this.hold_;
+        } catch (err) {
+          const { status, reason } = errInfo(err);
+          if (status === 409 && reason === "event_closed") {
+            this.opts.onSalesClosed?.();
+            throw err;
+          }
+        }
+      }
+    }
     if (this.hold_ && !await this.release()) return null;
     try {
       const result = await this.api.bestAvailable(this.key, qty, categoryKey);
@@ -5702,9 +5868,9 @@ function generateSeatThumb(seat, focalPoint, _neighborSeats) {
 
 // src/i18n/bundles.ts
 var LOADERS = {
-  es: () => import("./es-ALPR5FBB.js").then((m) => ({ default: m.es })),
-  de: () => import("./de-KPTY7UOT.js").then((m) => ({ default: m.de })),
-  fr: () => import("./fr-HVQLQD2N.js").then((m) => ({ default: m.fr }))
+  es: () => import("./es-N73CIVTC.js").then((m) => ({ default: m.es })),
+  de: () => import("./de-DRWMZ2FV.js").then((m) => ({ default: m.de })),
+  fr: () => import("./fr-SOY2OB4P.js").then((m) => ({ default: m.fr }))
 };
 var loaded = /* @__PURE__ */ new Set(["en"]);
 async function loadLocale(code) {