@bash-app/bash-common 30.336.0 → 30.338.0

package/src/seatMap.ts

@@ -0,0 +1,337 @@
+/**
+ * Shared seat map document shape (persisted on BashEvent.seatMap).
+ * Aligns with bash-app features/seatmap types.
+ */
+
+export type SeatMapSeatType = "seat" | "space";
+
+export type SeatMapSeat = {
+  id: string;
+  row: string;
+  type: string;
+  label: string;
+};
+
+/** Named block within a flat seat list (row keys belong to this section). */
+export type SeatMapSection = {
+  id: string;
+  name: string;
+  rowKeys: string[];
+};
+
+export type SeatMapDocument = {
+  id: string;
+  name: string;
+  venueId?: number;
+  venueName?: string;
+  blockId?: number;
+  blockName?: string;
+  stageText: string;
+  seatMapData?: SeatMapSeat[];
+  /** Multi-block maps from builder templates / CSV / AI import. */
+  sections?: SeatMapSection[];
+};
+
+function isSeatMapSection(value: unknown): value is SeatMapSection {
+  if (!value || typeof value !== "object") return false;
+  const s = value as Record<string, unknown>;
+  if (typeof s.id !== "string" || typeof s.name !== "string") return false;
+  if (!Array.isArray(s.rowKeys)) return false;
+  return s.rowKeys.every((k) => typeof k === "string");
+}
+
+export function isSeatMapDocument(value: unknown): value is SeatMapDocument {
+  if (!value || typeof value !== "object") return false;
+  const v = value as Record<string, unknown>;
+  if (typeof v.id !== "string" || typeof v.name !== "string") return false;
+  if (typeof v.stageText !== "string") return false;
+  if (v.seatMapData !== undefined && !Array.isArray(v.seatMapData)) return false;
+  if (Array.isArray(v.seatMapData)) {
+    for (const seat of v.seatMapData) {
+      if (!seat || typeof seat !== "object") return false;
+      const s = seat as Record<string, unknown>;
+      if (
+        typeof s.id !== "string" ||
+        typeof s.row !== "string" ||
+        typeof s.type !== "string" ||
+        typeof s.label !== "string"
+      ) {
+        return false;
+      }
+    }
+  }
+  if (v.sections !== undefined) {
+    if (!Array.isArray(v.sections)) return false;
+    if (!v.sections.every(isSeatMapSection)) return false;
+  }
+  return true;
+}
+
+/** Seat ids that are actual seats (not aisle/space placeholders). */
+export function seatIdsFromMap(map: SeatMapDocument | null | undefined): string[] {
+  if (!map?.seatMapData?.length) return [];
+  return map.seatMapData
+    .filter((s) => s.type === "seat" || (!s.type.startsWith("space") && s.type !== "space"))
+    .map((s) => s.id);
+}
+
+export function filterSeatMapToSeatIds(
+  map: SeatMapDocument,
+  seatIds: string[]
+): SeatMapDocument {
+  const allow = new Set(seatIds);
+  const seatMapData = (map.seatMapData ?? []).filter(
+    (s) => allow.has(s.id) || s.type === "space" || s.type.startsWith("empty")
+  );
+  return { ...map, seatMapData };
+}
+
+function isHallwayOrSpaceRow(rowKey: string, seatsInRow: SeatMapSeat[]): boolean {
+  if (rowKey.startsWith("empty-") || rowKey.startsWith("space")) return true;
+  return (
+    seatsInRow.length > 0 &&
+    seatsInRow.every(
+      (s) => s.type === "space" || s.type.startsWith("space") || s.type.startsWith("empty")
+    )
+  );
+}
+
+/**
+ * Prefix before the last `-` for keys like `Orchestra-A` → Orchestra.
+ * Plain `A` has no section prefix.
+ */
+export function sectionPrefixFromRowKey(rowKey: string): string | null {
+  const trimmed = rowKey.trim();
+  if (!trimmed || trimmed.startsWith("empty-")) return null;
+  const idx = trimmed.lastIndexOf("-");
+  if (idx <= 0) return null;
+  const prefix = trimmed.slice(0, idx).trim();
+  return prefix.length > 0 ? prefix : null;
+}
+
+/**
+ * Resolve sections for overview UI: prefer persisted `sections`, else derive
+ * from row-key prefixes / aisle separators.
+ */
+export function sectionsFromSeatMap(map: SeatMapDocument | null | undefined): SeatMapSection[] {
+  if (!map) return [];
+  if (map.sections?.length) {
+    return map.sections.filter((s) => s.rowKeys.length > 0);
+  }
+
+  const seats = map.seatMapData ?? [];
+  const rowOrder: string[] = [];
+  const byRow = new Map<string, SeatMapSeat[]>();
+  for (const s of seats) {
+    if (!byRow.has(s.row)) {
+      byRow.set(s.row, []);
+      rowOrder.push(s.row);
+    }
+    byRow.get(s.row)!.push(s);
+  }
+
+  type Acc = { name: string; rowKeys: string[] };
+  const derived: Acc[] = [];
+  let current: Acc | null = null;
+
+  for (const row of rowOrder) {
+    const inRow = byRow.get(row) ?? [];
+    if (isHallwayOrSpaceRow(row, inRow)) {
+      current = null;
+      continue;
+    }
+    const prefix = sectionPrefixFromRowKey(row);
+    const name =
+      prefix ?? (map.blockName?.trim() || map.name?.trim() || "Section");
+    if (!current || current.name !== name) {
+      current = { name, rowKeys: [row] };
+      derived.push(current);
+    } else {
+      current.rowKeys.push(row);
+    }
+  }
+
+  return derived.map((d, i) => ({
+    id: `derived-${i}-${d.name.replace(/\s+/g, "-").slice(0, 24)}`,
+    name: d.name,
+    rowKeys: d.rowKeys,
+  }));
+}
+
+/** Section display name for a row key (ticket denormalization). */
+export function sectionNameForRow(
+  map: SeatMapDocument | null | undefined,
+  rowKey: string
+): string | null {
+  if (!map) return null;
+  const sections = sectionsFromSeatMap(map);
+  const hit = sections.find((s) => s.rowKeys.includes(rowKey));
+  if (hit?.name?.trim()) return hit.name.trim();
+  return sectionFromMap(map);
+}
+
+export type SeatLocationDisplay = {
+  section: string | null;
+  row: string | null;
+  seat: string | null;
+  /** Full line for ticket details, e.g. "Orchestra · Row A · Seat 12". */
+  line: string;
+  /** Compact line for lists, e.g. "A12" or "Rows A–C". */
+  shortLine: string;
+};
+
+function sectionFromMap(map: SeatMapDocument | null | undefined): string | null {
+  if (!map) return null;
+  const block = map.blockName?.trim();
+  if (block) return block;
+  const name = map.name?.trim();
+  return name || null;
+}
+
+function joinLocationParts(parts: Array<string | null | undefined>): string {
+  return parts.filter((p): p is string => !!p && p.trim().length > 0).join(" · ");
+}
+
+function sortRowKeys(rows: string[]): string[] {
+  return [...rows].sort((a, b) =>
+    a.localeCompare(b, undefined, { numeric: true, sensitivity: "base" })
+  );
+}
+
+function formatRowRange(rows: string[]): string | null {
+  const sorted = sortRowKeys(rows);
+  if (sorted.length === 0) return null;
+  if (sorted.length === 1) return `Row ${sorted[0]}`;
+  return `Rows ${sorted[0]}–${sorted[sorted.length - 1]}`;
+}
+
+/** Single assigned seat (ticket row or map lookup). */
+export function formatAssignedSeatLocation(input: {
+  section?: string | null;
+  row?: string | null;
+  seat?: string | null;
+  map?: SeatMapDocument | null;
+  seatId?: string | null;
+}): SeatLocationDisplay | null {
+  let section = input.section?.trim() || null;
+  let row = input.row?.trim() || null;
+  let seat = input.seat?.trim() || null;
+
+  if ((!row || !seat) && input.map && input.seatId) {
+    const found = (input.map.seatMapData ?? []).find((s) => s.id === input.seatId);
+    if (found && found.type === "seat") {
+      row = row ?? found.row;
+      seat = seat ?? found.label;
+      if (!section) {
+        section = sectionNameForRow(input.map, found.row);
+      }
+    }
+  }
+  section = section ?? sectionFromMap(input.map ?? null);
+
+  if (!row && !seat && !section) return null;
+
+  const seatPart = seat ? `Seat ${seat}` : null;
+  const rowPart = row ? `Row ${row}` : null;
+  const short =
+    row && seat
+      ? `${row}${seat}`
+      : row
+        ? `Row ${row}`
+        : seat
+          ? `Seat ${seat}`
+          : section ?? "Seated";
+
+  return {
+    section,
+    row,
+    seat,
+    line: joinLocationParts([section, rowPart, seatPart]),
+    shortLine: short,
+  };
+}
+
+/**
+ * Tier inventory summary when seats aren't assigned per ticket yet
+ * (quantity checkout MVP).
+ */
+export function formatTierSeatingArea(
+  map: SeatMapDocument | null | undefined,
+  seatIds: string[] | null | undefined
+): SeatLocationDisplay | null {
+  if (!map || !seatIds?.length) return null;
+  const allow = new Set(seatIds);
+  const seats = (map.seatMapData ?? []).filter(
+    (s) => allow.has(s.id) && s.type === "seat"
+  );
+  if (seats.length === 0) return null;
+
+  const section = sectionFromMap(map);
+  const rows = [...new Set(seats.map((s) => s.row))];
+  const rowPart = formatRowRange(rows);
+  const countPart =
+    seats.length === 1 ? "1 seat" : `${seats.length} seats`;
+
+  const labels = seats
+    .map((s) => parseInt(s.label, 10))
+    .filter((n) => Number.isFinite(n))
+    .sort((a, b) => a - b);
+  let seatPart: string | null = countPart;
+  if (labels.length === seats.length && labels.length > 0) {
+    const min = labels[0];
+    const max = labels[labels.length - 1];
+    seatPart =
+      min === max ? `Seat ${min}` : `Seats ${min}–${max}`;
+  }
+
+  return {
+    section,
+    row: rows.length === 1 ? rows[0] : null,
+    seat: null,
+    line: joinLocationParts([section, rowPart, seatPart]),
+    shortLine: joinLocationParts([
+      section,
+      rowPart,
+      seats.length > 1 ? `${seats.length} seats` : seatPart,
+    ]),
+  };
+}
+
+export type TicketSeatingFields = {
+  seatId?: string | null;
+  seatSection?: string | null;
+  seatRow?: string | null;
+  seatLabel?: string | null;
+};
+
+export type TierSeatingFields = {
+  usesSeatMap?: boolean | null;
+  seatIds?: string[] | null;
+};
+
+/** Prefer a specific assigned seat; otherwise seated-tier area summary. */
+export function resolveTicketSeatingDisplay(
+  ticket: TicketSeatingFields | null | undefined,
+  tier: TierSeatingFields | null | undefined,
+  map: SeatMapDocument | null | undefined
+): SeatLocationDisplay | null {
+  if (
+    ticket?.seatId ||
+    ticket?.seatRow ||
+    ticket?.seatLabel ||
+    ticket?.seatSection
+  ) {
+    const assigned = formatAssignedSeatLocation({
+      section: ticket.seatSection,
+      row: ticket.seatRow,
+      seat: ticket.seatLabel,
+      map,
+      seatId: ticket.seatId,
+    });
+    if (assigned) return assigned;
+  }
+  if (tier?.usesSeatMap && tier.seatIds?.length) {
+    return formatTierSeatingArea(map, tier.seatIds);
+  }
+  return null;
+}

package/src/seatMapBestAvailable.ts

@@ -0,0 +1,174 @@
+/**
+ * Best-available seating: prefer contiguous seats in one row, then any contiguous
+ * row, then a split within the same section (marked non-contiguous).
+ */
+
+import {
+  sectionNameForRow,
+  type SeatMapDocument,
+  type SeatMapSeat,
+} from "./seatMap.js";
+
+export type BestAvailableResult =
+  | { ok: true; seatIds: string[]; contiguous: boolean }
+  | { ok: false; error: string };
+
+function isRealSeat(s: SeatMapSeat): boolean {
+  return (
+    s.type === "seat" ||
+    (!s.type.startsWith("space") &&
+      s.type !== "space" &&
+      !s.type.startsWith("empty"))
+  );
+}
+
+function seatSortKey(label: string): [number, string] {
+  const n = parseInt(label, 10);
+  if (Number.isFinite(n)) return [n, label];
+  return [Number.POSITIVE_INFINITY, label];
+}
+
+function sortSeatsInRow(seats: SeatMapSeat[]): SeatMapSeat[] {
+  return [...seats].sort((a, b) => {
+    const [na, sa] = seatSortKey(a.label);
+    const [nb, sb] = seatSortKey(b.label);
+    if (na !== nb) return na - nb;
+    return sa.localeCompare(sb, undefined, { numeric: true, sensitivity: "base" });
+  });
+}
+
+/** Labels are contiguous when consecutive numeric labels differ by 1. */
+function areAdjacent(a: SeatMapSeat, b: SeatMapSeat): boolean {
+  const na = parseInt(a.label, 10);
+  const nb = parseInt(b.label, 10);
+  if (Number.isFinite(na) && Number.isFinite(nb)) {
+    return Math.abs(na - nb) === 1;
+  }
+  return true;
+}
+
+function findContiguousRuns(sorted: SeatMapSeat[], qty: number): SeatMapSeat[][] {
+  if (qty <= 0 || sorted.length < qty) return [];
+  const runs: SeatMapSeat[][] = [];
+  for (let start = 0; start < sorted.length; start += 1) {
+    const run: SeatMapSeat[] = [sorted[start]];
+    for (let i = start + 1; i < sorted.length && run.length < qty; i += 1) {
+      if (!areAdjacent(run[run.length - 1], sorted[i])) break;
+      run.push(sorted[i]);
+    }
+    if (run.length === qty) {
+      runs.push(run);
+    }
+  }
+  return runs;
+}
+
+/**
+ * Pick `qty` open seats from the tier's inventory.
+ * Prefers contiguous seats in one row (earlier rows / toward stage first).
+ */
+export function findBestAvailableSeats(input: {
+  map: SeatMapDocument;
+  allowedSeatIds: string[];
+  blockedSeatIds: Iterable<string>;
+  qty: number;
+}): BestAvailableResult {
+  const qty = Math.floor(input.qty);
+  if (!Number.isFinite(qty) || qty <= 0) {
+    return { ok: false, error: "Choose how many seats you need" };
+  }
+
+  const allowed = new Set(input.allowedSeatIds);
+  const blocked = new Set(input.blockedSeatIds);
+  const open = (input.map.seatMapData ?? []).filter(
+    (s) => isRealSeat(s) && allowed.has(s.id) && !blocked.has(s.id)
+  );
+
+  if (open.length < qty) {
+    return {
+      ok: false,
+      error: "Not enough open seats left in this ticket — try fewer seats.",
+    };
+  }
+
+  const rowOrder: string[] = [];
+  const byRow = new Map<string, SeatMapSeat[]>();
+  for (const s of open) {
+    if (!byRow.has(s.row)) {
+      byRow.set(s.row, []);
+      rowOrder.push(s.row);
+    }
+    byRow.get(s.row)!.push(s);
+  }
+
+  type Candidate = { seats: SeatMapSeat[]; rowIndex: number; centerDist: number };
+  const contiguous: Candidate[] = [];
+
+  for (let ri = 0; ri < rowOrder.length; ri += 1) {
+    const sorted = sortSeatsInRow(byRow.get(rowOrder[ri])!);
+    const runs = findContiguousRuns(sorted, qty);
+    for (const run of runs) {
+      const mid = (sorted.length - 1) / 2;
+      const runMid =
+        (seatSortKey(run[0].label)[0] +
+          seatSortKey(run[run.length - 1].label)[0]) /
+        2;
+      const centerDist = Number.isFinite(runMid)
+        ? Math.abs(runMid - mid)
+        : Math.abs((run.length - 1) / 2 - mid);
+      contiguous.push({ seats: run, rowIndex: ri, centerDist });
+    }
+  }
+
+  contiguous.sort((a, b) => {
+    if (a.rowIndex !== b.rowIndex) return a.rowIndex - b.rowIndex;
+    return a.centerDist - b.centerDist;
+  });
+
+  if (contiguous.length > 0) {
+    return {
+      ok: true,
+      seatIds: contiguous[0].seats.map((s) => s.id),
+      contiguous: true,
+    };
+  }
+
+  const bySection = new Map<string, string[]>();
+  for (const row of rowOrder) {
+    const sec = sectionNameForRow(input.map, row) ?? "Section";
+    const list = bySection.get(sec) ?? [];
+    list.push(row);
+    bySection.set(sec, list);
+  }
+
+  for (const rows of bySection.values()) {
+    const picked: SeatMapSeat[] = [];
+    for (const row of rows) {
+      const sorted = sortSeatsInRow(byRow.get(row)!);
+      for (const s of sorted) {
+        picked.push(s);
+        if (picked.length === qty) {
+          return {
+            ok: true,
+            seatIds: picked.map((x) => x.id),
+            contiguous: false,
+          };
+        }
+      }
+    }
+  }
+
+  const any = open.slice(0, qty);
+  if (any.length === qty) {
+    return {
+      ok: true,
+      seatIds: any.map((s) => s.id),
+      contiguous: false,
+    };
+  }
+
+  return {
+    ok: false,
+    error: "Couldn't find seats together — try picking manually.",
+  };
+}

package/src/sms/smsTemplates.ts

@@ -8,6 +8,9 @@ export const SMS_TEMPLATE_KEYS = [
   "EVENT_REMINDER_3H",
   "EVENT_REMINDER_1H",
   "EVENT_VENUE_CHANGED",
+  "EVENT_TIME_CHANGED",
+  "EVENT_CANCELLED",
+  "EVENT_DETAILS_CHANGED",
   "EVENT_WAITLIST_APPROVED",
   "TICKET_CONFIRMED",
   "COAT_CHECK_CLAIM",
@@ -22,6 +25,14 @@ export type SmsTemplateContext = {
   EVENT_REMINDER_3H: { eventTitle: string; shortUrl: string };
   EVENT_REMINDER_1H: { eventTitle: string; shortUrl: string };
   EVENT_VENUE_CHANGED: { eventTitle: string; shortUrl: string };
+  EVENT_TIME_CHANGED: { eventTitle: string; shortUrl: string };
+  EVENT_CANCELLED: { eventTitle: string; shortUrl: string };
+  /** Batched critical updates (time + venue, etc.) from the 5-min debounce path. */
+  EVENT_DETAILS_CHANGED: {
+    eventTitle: string;
+    shortUrl: string;
+    whatChanged: string;
+  };
   EVENT_WAITLIST_APPROVED: { eventTitle: string; shortUrl: string };
   TICKET_CONFIRMED: { eventTitle: string; ticketCount: number; ticketsUrl?: string };
   COAT_CHECK_CLAIM: {

package/src/utils/__tests__/paymentUtils.test.ts

@@ -423,7 +423,7 @@ describe("PaymentUtils - Core Functions", () => {
     });
   });
 
-  describe("guest ticket checkout breakdown (No Fees for Attendees)", () => {
+  describe("guest ticket checkout breakdown (No Platform Fees. Free for Everyone.)", () => {
     test("HostAbsorbs — $20 ticket → $20 due, no processing line", () => {
       const r = computeGuestTicketCheckoutBreakdown({
         discountedSubtotalCents: 2000,

package/src/utils/__tests__/ticketListUtils.test.ts

@@ -113,4 +113,48 @@ describe("ticketListUtils", () => {
       );
     });
   });
+
+  test("round-trips seatIds for seated tiers", () => {
+    const ticketList = new Map<string, NumberOfTicketsForDate[]>([
+      [
+        "tier-seated",
+        [
+          {
+            numberOfTickets: 2,
+            ticketDateTime: isoDate,
+            seatIds: ["seat-a1", "seat-a2"],
+          },
+        ],
+      ],
+    ]);
+
+    const decoded = ticketListStrToTicketList(ticketListToString(ticketList));
+    expect(decoded.get("tier-seated")![0].seatIds).toEqual([
+      "seat-a1",
+      "seat-a2",
+    ]);
+    expect(decoded.get("tier-seated")![0].numberOfTickets).toBe(2);
+  });
+
+  test("round-trips seatHoldId with seatIds", () => {
+    const ticketList = new Map<string, NumberOfTicketsForDate[]>([
+      [
+        "tier-seated",
+        [
+          {
+            numberOfTickets: 2,
+            ticketDateTime: isoDate,
+            seatIds: ["seat-a1", "seat-a2"],
+            seatHoldId: "hold-xyz",
+          },
+        ],
+      ],
+    ]);
+    const decoded = ticketListStrToTicketList(ticketListToString(ticketList));
+    expect(decoded.get("tier-seated")![0].seatHoldId).toBe("hold-xyz");
+    expect(decoded.get("tier-seated")![0].seatIds).toEqual([
+      "seat-a1",
+      "seat-a2",
+    ]);
+  });
 });

package/src/utils/paymentUtils.ts

@@ -345,7 +345,7 @@ export function hostAbsorbsTicketProcessing(
 }
 
 /**
- * Whether the event qualifies for the public "No fees for attendees" badge.
+ * Whether the event qualifies for the public "No Platform Fees. Free for Everyone." badge.
  * External-ticket events are excluded (Bash does not control checkout).
  */
 export function guestCheckoutHasNoAddedFees(

package/src/utils/ticketListUtils.ts

@@ -79,11 +79,23 @@ export function ticketListToString(
           }
         }
 
+        const needsSeatHold =
+          !!ticketNumAndDates.seatHoldId && ticketNumAndDates.seatIds?.length;
         ticketArgs.push(
           `${ticketNumAndDates.numberOfTickets}${URL_PARAMS_TICKETS_DATE_DELIM}${dateTimeStr}${
             ticketNumAndDates.unitPriceCents != null &&
             ticketNumAndDates.unitPriceCents > 0
               ? `${URL_PARAMS_TICKETS_DATE_DELIM}${ticketNumAndDates.unitPriceCents}`
+              : ticketNumAndDates.seatIds?.length
+                ? `${URL_PARAMS_TICKETS_DATE_DELIM}`
+                : ""
+          }${
+            ticketNumAndDates.seatIds?.length
+              ? `${URL_PARAMS_TICKETS_DATE_DELIM}${ticketNumAndDates.seatIds.join("|")}`
+              : ""
+          }${
+            needsSeatHold
+              ? `${URL_PARAMS_TICKETS_DATE_DELIM}${ticketNumAndDates.seatHoldId}`
               : ""
           }`
         );
@@ -157,6 +169,8 @@ export function ticketListStrToTicketList(
       const numberOfTickets = segments[0];
       const ticketDateTimeStr = segments[1];
       const unitPriceCentsRaw = segments[2];
+      const seatIdsRaw = segments[3];
+      const seatHoldIdRaw = segments[4];
       const ticketDateTime = DateTime.fromISO(ticketDateTimeStr);
       let ticketDateTimeFormattedStr: string | undefined = undefined;
 
@@ -169,12 +183,24 @@ export function ticketListStrToTicketList(
           ? parseInt(unitPriceCentsRaw, 10)
           : undefined;
 
+      const seatIds =
+        seatIdsRaw != null && seatIdsRaw !== ""
+          ? seatIdsRaw.split("|").map((id) => id.trim()).filter(Boolean)
+          : undefined;
+
+      const seatHoldId =
+        seatHoldIdRaw != null && seatHoldIdRaw.trim() !== ""
+          ? seatHoldIdRaw.trim()
+          : undefined;
+
       ticketNumAndDatesArr.push({
         numberOfTickets: parseInt(numberOfTickets),
         ticketDateTime: ticketDateTimeFormattedStr,
         ...(unitPriceCents != null && !Number.isNaN(unitPriceCents)
           ? { unitPriceCents }
           : {}),
+        ...(seatIds?.length ? { seatIds } : {}),
+        ...(seatHoldId ? { seatHoldId } : {}),
       });
     }
     ticketList.set(ticketTierId, ticketNumAndDatesArr);