@bash-app/bash-common 30.386.0 → 30.391.0

package/src/index.ts

@@ -36,6 +36,7 @@ export * from "./accessScreening.js";
 export * from "./applicationFunnel.js";
 export * from "./hostCrmSegments.js";
 export * from "./hostCrmCrowdPulse.js";
+export * from "./scenePulse.js";
 export * from "./hostCrmLastBashProof.js";
 export * from "./hostCrmInsights.js";
 export * from "./hostCrmAutomation.js";
@@ -107,6 +108,8 @@ export {
   BrandStrategistFormat,
   CPAsFormat,
   CateringFormat,
+  CelebrationCakeFormat,
+  GrazingTableFormat,
   CelebrityAppearanceFormat,
   CenterpiecesFormat,
   ChairsFormat,
@@ -189,6 +192,7 @@ export {
   NotificationPriority,
   NotificationType,
   Occupation,
+  OfficiantFormat,
   OfferClaimStatus,
   OfferDiscountType,
   OrganizationArtistInvitationStatus,
@@ -225,6 +229,7 @@ export {
   RecurringFrequency,
   RedemptionMethod,
   RentalEquipmentSubType,
+  RestroomTrailerFormat,
   ReportStatus,
   ReportingFormat,
   RewardReportStatus,
@@ -429,6 +434,7 @@ export * from "./utils/mathUtils.js";
 export * from "./utils/birthdayExperienceQuality.js";
 export * from "./utils/service/apiServiceBookingApiUtils.js";
 export * from "./utils/service/frontendServiceBookingUtils.js";
+export * from "./utils/service/foodAndBeverageQuote.js";
 export * from "./utils/service/serviceBookingStatusUtils.js";
 export * from "./utils/service/serviceDBUtils.js";
 export * from "./utils/service/serviceRateUtils.js";

package/src/scenePulse.ts

@@ -0,0 +1,113 @@
+/**
+ * Community Builder scene pulse — city / region / world aggregates.
+ * You (Crowd Pulse) stays host ops; these scopes are public scene energy + platform proof.
+ */
+
+export const SCENE_PULSE_SCOPES = ["city", "region", "world"] as const;
+
+export type ScenePulseScope = (typeof SCENE_PULSE_SCOPES)[number];
+
+export type ScenePulseGeo = {
+  city: string | null;
+  state: string | null;
+  country: string | null;
+  /** Short label for copy ("Salt Lake City", "Utah", "World"). */
+  label: string;
+  timeZone: string;
+};
+
+export type ScenePulseEnergy = {
+  /** Public rooms currently live. */
+  liveNow: number;
+  /** Unique Going RSVPs + ticketed people on live + tonight + this weekend. */
+  going: number;
+  tonightBashes: number;
+  tonightGoing: number;
+  weekendBashes: number;
+  weekendGoing: number;
+  /** Unique people who RSVP'd Going or paid for a ticket in the last 7 days. */
+  newThisWeek: number;
+  /**
+   * Distinct live/tonight/weekend public bashes with a lineup slot or a
+   * host-spotlighted featured guest (names in the room — not CRM).
+   */
+  namesInTheRoom: number;
+};
+
+/** World-only cumulative credibility. Null on city/region. */
+export type ScenePulseWorldCred = {
+  totalPeople: number;
+  bashesHosted: number;
+  ticketsSold: number;
+  gmvCents: number;
+  citiesRepresented: number;
+  regionsRepresented: number;
+};
+
+export type ScenePulse = {
+  scope: ScenePulseScope;
+  geo: ScenePulseGeo | null;
+  /** True when city (or region) can't be resolved from profile or hosted bashes. */
+  needsLocation: boolean;
+  energy: ScenePulseEnergy;
+  world: ScenePulseWorldCred | null;
+};
+
+/** Optional city/state used to pulse a scene other than the host's profile. */
+export type ScenePulseGeoOverride = {
+  city: string | null;
+  state: string | null;
+};
+
+const MAX_GEO_CITY_CHARS = 80;
+const MAX_GEO_STATE_CHARS = 40;
+
+function normalizeGeoPart(raw: unknown, maxChars: number): string | null {
+  if (typeof raw !== "string") return null;
+  const trimmed = raw.replace(/\s+/g, " ").trim();
+  if (!trimmed) return null;
+  return trimmed.slice(0, maxChars);
+}
+
+/**
+ * Blank city+state → null (use profile). Otherwise a trimmed override.
+ */
+export function normalizeScenePulseGeoOverride(input: {
+  city?: unknown;
+  state?: unknown;
+}): ScenePulseGeoOverride | null {
+  const city = normalizeGeoPart(input.city, MAX_GEO_CITY_CHARS);
+  const state = normalizeGeoPart(input.state, MAX_GEO_STATE_CHARS);
+  if (!city && !state) return null;
+  return { city, state };
+}
+
+export function emptyScenePulseEnergy(): ScenePulseEnergy {
+  return {
+    liveNow: 0,
+    going: 0,
+    tonightBashes: 0,
+    tonightGoing: 0,
+    weekendBashes: 0,
+    weekendGoing: 0,
+    newThisWeek: 0,
+    namesInTheRoom: 0,
+  };
+}
+
+/**
+ * Missing / blank → city. Invalid string → null (caller should 400).
+ */
+export function parseScenePulseScope(raw: unknown): ScenePulseScope | null {
+  if (raw == null || raw === "") return "city";
+  if (typeof raw !== "string") return null;
+  const normalized = raw.trim().toLowerCase();
+  if (
+    normalized === "city" ||
+    normalized === "region" ||
+    normalized === "world"
+  ) {
+    return normalized;
+  }
+  return null;
+}

package/src/utils/service/__tests__/foodAndBeverageQuote.test.ts

@@ -0,0 +1,502 @@
+import {
+  CELEBRATION_CAKE_FLAVORS,
+  EVENT_SERVICE_FULFILLMENT_MODES,
+  celebrationCakeStartingPriceLabel,
+  encodeCakeOption,
+  filterCelebrationCakeFulfillmentModes,
+  filterFulfillmentModes,
+  foodAndBeverageLeadTimeLabel,
+  foodAndBeverageQuoteCents,
+  foodAndBeverageRateSummary,
+  getFoodAndBeverageMenuCategories,
+  isBelowGuestMinimum,
+  GRAZING_TABLE_STYLES,
+  encodeGrazingOption,
+  grazingTableStartingPriceLabel,
+  isCelebrationCakeEventService,
+  isCelebrationCakeFulfillmentMode,
+  isFoodAndBeverageEventService,
+  isFulfillmentMode,
+  isGrazingTableEventService,
+  isOfficiantEventService,
+  isPackagePricedFoodEventService,
+  isPerGuestFoodAndBeverageEventService,
+  packagePricedFoodStartingPriceLabel,
+  parseCakeOptions,
+  parseGrazingOptions,
+  quotedGuestCount,
+  serializeCakeOptions,
+  serializeGrazingOptions,
+} from "../foodAndBeverageQuote.js";
+
+describe("isFoodAndBeverageEventService", () => {
+  it("returns true for FoodAndBeverage eventServiceType", () => {
+    expect(
+      isFoodAndBeverageEventService({ eventServiceType: "FoodAndBeverage" })
+    ).toBe(true);
+  });
+
+  it("returns true for canonical subtype even without eventServiceType", () => {
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "Caterer" })
+    ).toBe(true);
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "DessertBar" })
+    ).toBe(true);
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "CelebrationCake" })
+    ).toBe(true);
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "GrazingTable" })
+    ).toBe(true);
+  });
+
+  it("returns true for legacy/alias subtypes", () => {
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "PrivateChef" })
+    ).toBe(true);
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "Bartender" })
+    ).toBe(true);
+  });
+
+  it("returns false for unrelated types", () => {
+    expect(
+      isFoodAndBeverageEventService({ eventServiceType: "EventPlanningAndManagement" })
+    ).toBe(false);
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "EventPlanner" })
+    ).toBe(false);
+  });
+
+  it("returns false when both are null/undefined", () => {
+    expect(isFoodAndBeverageEventService({})).toBe(false);
+    expect(isFoodAndBeverageEventService({ eventServiceType: null, eventServiceSubType: null })).toBe(false);
+  });
+});
+
+describe("EVENT_SERVICE_FULFILLMENT_MODES", () => {
+  it("contains Pickup, Delivery, and FullService", () => {
+    expect(EVENT_SERVICE_FULFILLMENT_MODES).toContain("Pickup");
+    expect(EVENT_SERVICE_FULFILLMENT_MODES).toContain("Delivery");
+    expect(EVENT_SERVICE_FULFILLMENT_MODES).toContain("FullService");
+    expect(EVENT_SERVICE_FULFILLMENT_MODES).toHaveLength(3);
+  });
+});
+
+describe("getFoodAndBeverageMenuCategories", () => {
+  it("returns Caterer chips for Caterer subtype", () => {
+    const chips = getFoodAndBeverageMenuCategories("Caterer");
+    expect(chips).toContain("Salads");
+    expect(chips).toContain("Mains");
+    expect(chips).toContain("Sides");
+  });
+
+  it("returns DessertBar chips for DessertBar subtype", () => {
+    const chips = getFoodAndBeverageMenuCategories("DessertBar");
+    expect(chips).toContain("Cakes");
+    expect(chips).toContain("Cupcakes");
+  });
+
+  it("falls back to generic chips for unknown subtypes", () => {
+    const chips = getFoodAndBeverageMenuCategories("SomeUnknownType");
+    expect(chips.length).toBeGreaterThan(0);
+    expect(chips).toContain("Mains");
+  });
+
+  it("returns generic chips for null subtype", () => {
+    const chips = getFoodAndBeverageMenuCategories(null);
+    expect(chips.length).toBeGreaterThan(0);
+  });
+});
+
+describe("quotedGuestCount", () => {
+  it("returns headcount when no minimum is set", () => {
+    expect(quotedGuestCount(80)).toBe(80);
+    expect(quotedGuestCount(80, null)).toBe(80);
+    expect(quotedGuestCount(80, 0)).toBe(80);
+  });
+
+  it("returns headcount when above minimum", () => {
+    expect(quotedGuestCount(80, 25)).toBe(80);
+  });
+
+  it("floors to minimum when headcount is below", () => {
+    expect(quotedGuestCount(10, 25)).toBe(25);
+    expect(quotedGuestCount(0, 25)).toBe(25);
+  });
+
+  it("returns minimum exactly when headcount equals minimum", () => {
+    expect(quotedGuestCount(25, 25)).toBe(25);
+  });
+
+  it("never returns a negative count", () => {
+    expect(quotedGuestCount(-5)).toBe(0);
+  });
+});
+
+describe("foodAndBeverageQuoteCents", () => {
+  it("calculates basic per-guest price", () => {
+    // $18/guest × 100 guests = $1,800
+    expect(
+      foodAndBeverageQuoteCents({ baseRateCents: 1800, headcount: 100 })
+    ).toBe(180000);
+  });
+
+  it("floors headcount at minimumQuantity", () => {
+    // $18/guest × min 25 guests; host enters 10 → billed for 25
+    expect(
+      foodAndBeverageQuoteCents({
+        baseRateCents: 1800,
+        headcount: 10,
+        minimumQuantity: 25,
+      })
+    ).toBe(1800 * 25);
+  });
+
+  it("does not floor when headcount is above minimum", () => {
+    expect(
+      foodAndBeverageQuoteCents({
+        baseRateCents: 1800,
+        headcount: 80,
+        minimumQuantity: 25,
+      })
+    ).toBe(1800 * 80);
+  });
+
+  it("applies minimumChargeCents dollar floor after guest floor", () => {
+    // $8/guest × 25 guests (floored from 5) = $200. Min charge $500 → $500.
+    expect(
+      foodAndBeverageQuoteCents({
+        baseRateCents: 800,
+        headcount: 5,
+        minimumQuantity: 25,
+        minimumChargeCents: 50000,
+      })
+    ).toBe(50000);
+  });
+
+  it("dollar floor does not fire when rate total already exceeds it", () => {
+    // $18/guest × 50 guests = $900 > $500 min charge
+    expect(
+      foodAndBeverageQuoteCents({
+        baseRateCents: 1800,
+        headcount: 50,
+        minimumQuantity: 25,
+        minimumChargeCents: 50000,
+      })
+    ).toBe(1800 * 50);
+  });
+
+  it("returns 0 for zero baseRate", () => {
+    expect(
+      foodAndBeverageQuoteCents({ baseRateCents: 0, headcount: 100 })
+    ).toBe(0);
+  });
+
+  it("returns 0 for negative headcount", () => {
+    expect(
+      foodAndBeverageQuoteCents({ baseRateCents: 1800, headcount: -1 })
+    ).toBe(0);
+  });
+});
+
+describe("foodAndBeverageRateSummary", () => {
+  it("formats without a minimum", () => {
+    const result = foodAndBeverageRateSummary(1800);
+    expect(result).toBe("$18 / guest");
+  });
+
+  it("formats with a minimum", () => {
+    const result = foodAndBeverageRateSummary(1800, 25);
+    expect(result).toBe("$18 / guest · min 25 guests");
+  });
+
+  it("formats cents correctly", () => {
+    const result = foodAndBeverageRateSummary(1850);
+    expect(result).toBe("$18.50 / guest");
+  });
+});
+
+describe("foodAndBeverageLeadTimeLabel", () => {
+  it("returns null for falsy inputs", () => {
+    expect(foodAndBeverageLeadTimeLabel(null)).toBeNull();
+    expect(foodAndBeverageLeadTimeLabel(0)).toBeNull();
+    expect(foodAndBeverageLeadTimeLabel(undefined)).toBeNull();
+  });
+
+  it("formats days when not divisible by 7", () => {
+    expect(foodAndBeverageLeadTimeLabel(1)).toBe("Needs 1 day notice");
+    expect(foodAndBeverageLeadTimeLabel(5)).toBe("Needs 5 days notice");
+    expect(foodAndBeverageLeadTimeLabel(10)).toBe("Needs 10 days notice");
+  });
+
+  it("formats weeks when divisible by 7", () => {
+    expect(foodAndBeverageLeadTimeLabel(7)).toBe("Needs 1 week notice");
+    expect(foodAndBeverageLeadTimeLabel(14)).toBe("Needs 2 weeks notice");
+  });
+});
+
+describe("package-priced food detection", () => {
+  it("treats cake and grazing as package-priced, not per-guest", () => {
+    expect(
+      isPackagePricedFoodEventService({ eventServiceSubType: "CelebrationCake" })
+    ).toBe(true);
+    expect(
+      isPackagePricedFoodEventService({ eventServiceSubType: "GrazingTable" })
+    ).toBe(true);
+    expect(
+      isPackagePricedFoodEventService({ eventServiceSubType: "Caterer" })
+    ).toBe(false);
+    expect(isPackagePricedFoodEventService({})).toBe(false);
+  });
+
+  it("isPerGuestFoodAndBeverage is false for cake and grazing", () => {
+    expect(
+      isPerGuestFoodAndBeverageEventService({
+        eventServiceType: "FoodAndBeverage",
+        eventServiceSubType: "CelebrationCake",
+      })
+    ).toBe(false);
+    expect(
+      isPerGuestFoodAndBeverageEventService({
+        eventServiceType: "FoodAndBeverage",
+        eventServiceSubType: "GrazingTable",
+      })
+    ).toBe(false);
+    expect(
+      isPerGuestFoodAndBeverageEventService({
+        eventServiceType: "FoodAndBeverage",
+        eventServiceSubType: "Caterer",
+      })
+    ).toBe(true);
+  });
+
+  it("isGrazingTableEventService is true only for GrazingTable", () => {
+    expect(
+      isGrazingTableEventService({ eventServiceSubType: "GrazingTable" })
+    ).toBe(true);
+    expect(
+      isGrazingTableEventService({ eventServiceSubType: "CelebrationCake" })
+    ).toBe(false);
+    expect(isGrazingTableEventService({})).toBe(false);
+  });
+
+  it("isOfficiantEventService is true only for Officiant", () => {
+    expect(isOfficiantEventService({ eventServiceSubType: "Officiant" })).toBe(
+      true
+    );
+    expect(
+      isOfficiantEventService({ eventServiceSubType: "HostingSupportOther" })
+    ).toBe(false);
+    expect(isFoodAndBeverageEventService({ eventServiceSubType: "Officiant" })).toBe(
+      false
+    );
+  });
+});
+
+describe("isCelebrationCakeEventService", () => {
+  it("returns true only for CelebrationCake", () => {
+    expect(
+      isCelebrationCakeEventService({ eventServiceSubType: "CelebrationCake" })
+    ).toBe(true);
+    expect(
+      isCelebrationCakeEventService({ eventServiceSubType: "Caterer" })
+    ).toBe(false);
+    expect(
+      isCelebrationCakeEventService({ eventServiceSubType: "DessertBar" })
+    ).toBe(false);
+    expect(isCelebrationCakeEventService({})).toBe(false);
+    expect(isCelebrationCakeEventService({ eventServiceSubType: null })).toBe(
+      false
+    );
+  });
+});
+
+describe("parseCakeOptions", () => {
+  it("returns empty groups for null or empty input", () => {
+    expect(parseCakeOptions(null)).toEqual({
+      flavors: [],
+      frostings: [],
+      fillings: [],
+      dietary: [],
+      other: [],
+    });
+    expect(parseCakeOptions([])).toEqual({
+      flavors: [],
+      frostings: [],
+      fillings: [],
+      dietary: [],
+      other: [],
+    });
+  });
+
+  it("splits prefixed chips and keeps unprefixed leftovers", () => {
+    const parsed = parseCakeOptions([
+      "flavor:Red Velvet",
+      "frosting:Chocolate Buttercream",
+      "filling:Lemon Custard",
+      "dietary:Gluten-Free",
+      "Desserts",
+    ]);
+    expect(parsed.flavors).toEqual(["Red Velvet"]);
+    expect(parsed.frostings).toEqual(["Chocolate Buttercream"]);
+    expect(parsed.fillings).toEqual(["Lemon Custard"]);
+    expect(parsed.dietary).toEqual(["Gluten-Free"]);
+    expect(parsed.other).toEqual(["Desserts"]);
+  });
+
+  it("round-trips through serializeCakeOptions", () => {
+    const serialized = serializeCakeOptions({
+      flavors: ["Vanilla", "Chocolate"],
+      frostings: ["Fondant"],
+      fillings: [],
+      dietary: ["Vegan"],
+    });
+    expect(serialized).toEqual([
+      "flavor:Vanilla",
+      "flavor:Chocolate",
+      "frosting:Fondant",
+      "dietary:Vegan",
+    ]);
+    expect(parseCakeOptions(serialized)).toEqual({
+      flavors: ["Vanilla", "Chocolate"],
+      frostings: ["Fondant"],
+      fillings: [],
+      dietary: ["Vegan"],
+      other: [],
+    });
+  });
+
+  it("encodeCakeOption uses lowercase prefixes", () => {
+    expect(encodeCakeOption("flavor", "Red Velvet")).toBe("flavor:Red Velvet");
+    expect(CELEBRATION_CAKE_FLAVORS).toContain("Red Velvet");
+  });
+});
+
+describe("celebrationCakeStartingPriceLabel", () => {
+  it("returns null when there is no starting price", () => {
+    expect(celebrationCakeStartingPriceLabel(null)).toBeNull();
+    expect(celebrationCakeStartingPriceLabel(0)).toBeNull();
+  });
+
+  it("formats whole-dollar starting prices", () => {
+    expect(celebrationCakeStartingPriceLabel(35000)).toBe("Cakes start at $350");
+  });
+});
+
+describe("grazing options", () => {
+  it("returns empty groups for null or empty input", () => {
+    expect(parseGrazingOptions(null)).toEqual({
+      styles: [],
+      proteins: [],
+      dietary: [],
+      other: [],
+    });
+    expect(parseGrazingOptions([])).toEqual({
+      styles: [],
+      proteins: [],
+      dietary: [],
+      other: [],
+    });
+  });
+
+  it("splits prefixed chips and keeps unprefixed leftovers", () => {
+    const parsed = parseGrazingOptions([
+      "style:Classic Charcuterie",
+      "protein:Cured Meats",
+      "dietary:Gluten-Free",
+      "Mains",
+    ]);
+    expect(parsed.styles).toEqual(["Classic Charcuterie"]);
+    expect(parsed.proteins).toEqual(["Cured Meats"]);
+    expect(parsed.dietary).toEqual(["Gluten-Free"]);
+    expect(parsed.other).toEqual(["Mains"]);
+  });
+
+  it("round-trips through serializeGrazingOptions", () => {
+    const serialized = serializeGrazingOptions({
+      styles: ["Modern Grazing"],
+      proteins: ["Artisan Cheeses"],
+      dietary: ["Vegan"],
+    });
+    expect(serialized).toEqual([
+      "style:Modern Grazing",
+      "protein:Artisan Cheeses",
+      "dietary:Vegan",
+    ]);
+    expect(parseGrazingOptions(serialized)).toEqual({
+      styles: ["Modern Grazing"],
+      proteins: ["Artisan Cheeses"],
+      dietary: ["Vegan"],
+      other: [],
+    });
+  });
+
+  it("encodeGrazingOption uses lowercase prefixes", () => {
+    expect(encodeGrazingOption("style", "Seasonal")).toBe("style:Seasonal");
+    expect(GRAZING_TABLE_STYLES).toContain("Classic Charcuterie");
+  });
+});
+
+describe("grazing and package starting-price labels", () => {
+  it("formats grazing starting prices", () => {
+    expect(grazingTableStartingPriceLabel(null)).toBeNull();
+    expect(grazingTableStartingPriceLabel(17500)).toBe("Boards start at $175");
+  });
+
+  it("delegates packagePricedFoodStartingPriceLabel by subtype", () => {
+    expect(packagePricedFoodStartingPriceLabel("GrazingTable", 17500)).toBe(
+      "Boards start at $175"
+    );
+    expect(packagePricedFoodStartingPriceLabel("CelebrationCake", 35000)).toBe(
+      "Cakes start at $350"
+    );
+    expect(packagePricedFoodStartingPriceLabel("Caterer", 35000)).toBeNull();
+  });
+});
+
+describe("isBelowGuestMinimum", () => {
+  it("returns false when no minimum is set", () => {
+    expect(isBelowGuestMinimum(5)).toBe(false);
+    expect(isBelowGuestMinimum(5, null)).toBe(false);
+    expect(isBelowGuestMinimum(5, 0)).toBe(false);
+  });
+
+  it("returns true when below minimum", () => {
+    expect(isBelowGuestMinimum(10, 25)).toBe(true);
+  });
+
+  it("returns false when exactly at minimum", () => {
+    expect(isBelowGuestMinimum(25, 25)).toBe(false);
+  });
+
+  it("returns false when above minimum", () => {
+    expect(isBelowGuestMinimum(100, 25)).toBe(false);
+  });
+});
+
+describe("fulfillment mode filters", () => {
+  it("keeps known F&B modes and drops unknowns", () => {
+    expect(isFulfillmentMode("Pickup")).toBe(true);
+    expect(isFulfillmentMode("FullService")).toBe(true);
+    expect(isFulfillmentMode("Curbside")).toBe(false);
+    expect(
+      filterFulfillmentModes(["Pickup", "Curbside", "Delivery", "FullService"])
+    ).toEqual(["Pickup", "Delivery", "FullService"]);
+    expect(filterFulfillmentModes(null)).toEqual([]);
+  });
+
+  it("keeps cake pickup/delivery only", () => {
+    expect(isCelebrationCakeFulfillmentMode("Pickup")).toBe(true);
+    expect(isCelebrationCakeFulfillmentMode("FullService")).toBe(false);
+    expect(
+      filterCelebrationCakeFulfillmentModes([
+        "Pickup",
+        "FullService",
+        "Delivery",
+      ])
+    ).toEqual(["Pickup", "Delivery"]);
+    expect(filterCelebrationCakeFulfillmentModes(undefined)).toEqual([]);
+  });
+});