@bash-app/bash-common 30.385.0 → 30.391.0

package/src/utils/service/foodAndBeverageQuote.ts

@@ -0,0 +1,613 @@
+/**
+ * Shared quote logic for Food & Beverage event-service listings.
+ *
+ * Rules:
+ *  - Priced per-guest (PER_ATTENDEE pricingModel).
+ *  - Headcount floors at minimumQuantity if set.
+ *  - Dollar total floors at minimumChargeCents if set.
+ *  - Packages and add-ons still stack on top.
+ *  - No check-in true-up (promoter settlement) — headcount is snapshotted
+ *    at booking time only.
+ *
+ * Keep this module pure (no Prisma, no React). Import it in bash-app, api,
+ * and frontendServiceBookingUtils via the index.
+ */
+
+// ---------------------------------------------------------------------------
+// Subtype detection
+// ---------------------------------------------------------------------------
+
+/**
+ * All FoodAndBeverageSubType values (mirrors the Prisma enum).
+ * Also include legacy/alias strings the wizard uses (Caterer, PrivateChef, etc.)
+ * so detection works before the DB normalises them.
+ */
+export const FOOD_AND_BEVERAGE_SUBTYPES = new Set([
+  // Canonical FoodAndBeverageSubType values
+  "Caterer",
+  "FoodTruck",
+  "FoodCartStand",
+  "PrivateChefs",
+  "Bartenders",
+  "Baristas",
+  "Mixologist",
+  "Sommelier",
+  "DessertBar",
+  "BeverageCart",
+  "ConcessionStand",
+  "CelebrationCake",
+  "GrazingTable",
+  "FoodAndBeverageOther",
+  // Wizard aliases / legacy keys
+  "PrivateChef",
+  "Bartender",
+  "Barista",
+]);
+
+/**
+ * Custom-order celebration cakes — consultation, serving-size packages,
+ * pickup/delivery. Not a dessert station (DessertBar) and not per-guest catering.
+ */
+export function isCelebrationCakeEventService(opts: {
+  eventServiceSubType?: string | null;
+}): boolean {
+  return opts.eventServiceSubType === "CelebrationCake";
+}
+
+/**
+ * Charcuterie boards and grazing tables — board/table packages, not per-guest catering.
+ */
+export function isGrazingTableEventService(opts: {
+  eventServiceSubType?: string | null;
+}): boolean {
+  return opts.eventServiceSubType === "GrazingTable";
+}
+
+/**
+ * Wedding / ceremony officiant. Hosting Support — not F&B, not Entertainment Emcee.
+ */
+export function isOfficiantEventService(opts: {
+  eventServiceSubType?: string | null;
+}): boolean {
+  return opts.eventServiceSubType === "Officiant";
+}
+
+/** Cake and grazing: CUSTOM starting price + ServicePackage tiers. Never per-guest. */
+export const PACKAGE_PRICED_FOOD_SUBTYPES = new Set([
+  "CelebrationCake",
+  "GrazingTable",
+]);
+
+export function isPackagePricedFoodEventService(opts: {
+  eventServiceSubType?: string | null;
+}): boolean {
+  return (
+    !!opts.eventServiceSubType &&
+    PACKAGE_PRICED_FOOD_SUBTYPES.has(opts.eventServiceSubType)
+  );
+}
+
+/**
+ * Return true when a listing is an F&B EventService — either by top-level
+ * type or by subtype string (for legacy/alias safety).
+ */
+export function isFoodAndBeverageEventService(opts: {
+  eventServiceType?: string | null;
+  eventServiceSubType?: string | null;
+}): boolean {
+  if (opts.eventServiceType === "FoodAndBeverage") return true;
+  if (opts.eventServiceSubType && FOOD_AND_BEVERAGE_SUBTYPES.has(opts.eventServiceSubType))
+    return true;
+  return false;
+}
+
+/**
+ * Per-guest F&B only. Cake and grazing use packages — never this path.
+ */
+export function isPerGuestFoodAndBeverageEventService(opts: {
+  eventServiceType?: string | null;
+  eventServiceSubType?: string | null;
+}): boolean {
+  return (
+    isFoodAndBeverageEventService(opts) && !isPackagePricedFoodEventService(opts)
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Fulfillment modes
+// ---------------------------------------------------------------------------
+
+export const EVENT_SERVICE_FULFILLMENT_MODES = [
+  "Pickup",
+  "Delivery",
+  "FullService",
+] as const;
+
+export type FoodAndBeverageFulfillmentMode =
+  (typeof EVENT_SERVICE_FULFILLMENT_MODES)[number];
+
+const FULFILLMENT_MODE_SET: ReadonlySet<string> = new Set(
+  EVENT_SERVICE_FULFILLMENT_MODES
+);
+
+export function isFulfillmentMode(
+  mode: string
+): mode is FoodAndBeverageFulfillmentMode {
+  return FULFILLMENT_MODE_SET.has(mode);
+}
+
+export function filterFulfillmentModes(
+  modes?: readonly string[] | null
+): FoodAndBeverageFulfillmentMode[] {
+  return (modes ?? []).filter(isFulfillmentMode);
+}
+
+export const FULFILLMENT_MODE_LABEL: Record<FoodAndBeverageFulfillmentMode, string> = {
+  Pickup: "Pickup",
+  Delivery: "Delivery",
+  FullService: "Full Service",
+};
+
+// ---------------------------------------------------------------------------
+// Menu category chips per subtype
+// ---------------------------------------------------------------------------
+
+/**
+ * Suggested menu category chips shown in the wizard and on the listing.
+ * Providers can add custom values; these are just pre-populated starting points.
+ * Not SKUs — no flavors, quantities, or prices here.
+ */
+export const FB_MENU_CATEGORY_SUGGESTIONS: Record<string, readonly string[]> = {
+  Caterer: [
+    "Appetizers",
+    "Salads",
+    "Sandwiches",
+    "Mains",
+    "Sides",
+    "Desserts",
+    "Beverages",
+    "Vegetarian",
+    "Vegan",
+    "Gluten-Free",
+  ],
+  DessertBar: [
+    "Cakes",
+    "Cupcakes",
+    "Cookies",
+    "Dessert Table",
+    "Chocolate Fountain",
+    "Ice Cream",
+    "Candy Buffet",
+    "Gluten-Free",
+    "Vegan",
+    "Custom Orders",
+  ],
+  FoodTruck: [
+    "Street Food",
+    "Burgers",
+    "Tacos",
+    "Pizza",
+    "BBQ",
+    "Ethnic Cuisine",
+    "Desserts",
+    "Vegan",
+    "Gluten-Free",
+  ],
+  PrivateChef: [
+    "Appetizers",
+    "Multi-Course Dinner",
+    "Wine Pairing",
+    "Dietary Specialist",
+    "Tasting Menu",
+    "Family-Style",
+  ],
+  PrivateChefs: [
+    "Appetizers",
+    "Multi-Course Dinner",
+    "Wine Pairing",
+    "Dietary Specialist",
+    "Tasting Menu",
+    "Family-Style",
+  ],
+  Bartenders: [
+    "Cocktails",
+    "Beer & Wine",
+    "Open Bar",
+    "Mocktails",
+    "Craft Beer",
+    "Specialty Drinks",
+  ],
+  Bartender: [
+    "Cocktails",
+    "Beer & Wine",
+    "Open Bar",
+    "Mocktails",
+    "Craft Beer",
+    "Specialty Drinks",
+  ],
+  Baristas: ["Espresso", "Cold Brew", "Lattes", "Tea", "Specialty Beverages"],
+  Barista: ["Espresso", "Cold Brew", "Lattes", "Tea", "Specialty Beverages"],
+  FoodCartStand: [
+    "Street Food",
+    "Snacks",
+    "Desserts",
+    "Coffee",
+    "Specialty Station",
+  ],
+  BeverageCart: ["Coffee", "Tea", "Juice", "Smoothies", "Mocktails", "Water"],
+};
+
+/**
+ * Get suggested menu categories for a subtype.
+ * Falls back to a generic list if the subtype is not found.
+ */
+export function getFoodAndBeverageMenuCategories(subtype?: string | null): readonly string[] {
+  if (subtype && FB_MENU_CATEGORY_SUGGESTIONS[subtype]) {
+    return FB_MENU_CATEGORY_SUGGESTIONS[subtype];
+  }
+  return ["Mains", "Sides", "Desserts", "Beverages", "Dietary Options"];
+}
+
+// ---------------------------------------------------------------------------
+// Quote math
+// ---------------------------------------------------------------------------
+
+export interface FoodAndBeverageQuoteParams {
+  /** Cents per guest (baseRateCents from EventService). */
+  baseRateCents: number;
+  /** Host-entered guest count for the booking. */
+  headcount: number;
+  /** Minimum bookable guests (minimumQuantity from EventService). 0 = no floor. */
+  minimumQuantity?: number | null;
+  /** Hard dollar floor regardless of headcount (minimumChargeCents). 0 = no floor. */
+  minimumChargeCents?: number | null;
+}
+
+/**
+ * The effective guest count used for the quote.
+ * Floors at minimumQuantity so the provider is never charged less than their floor.
+ */
+export function quotedGuestCount(
+  headcount: number,
+  minimumQuantity?: number | null
+): number {
+  if (!minimumQuantity || minimumQuantity <= 0) return Math.max(0, headcount);
+  return Math.max(headcount, minimumQuantity);
+}
+
+/**
+ * Total food & beverage quote in cents, before packages, add-ons, and fees.
+ *
+ * Calculation order (mirrors the brochure's structure):
+ *  1. Floor headcount at minimumQuantity → quotedGuests
+ *  2. Compute rate total: baseRateCents × quotedGuests
+ *  3. Floor at minimumChargeCents
+ *
+ * Packages and add-ons are NOT included here — they are added on top by
+ * frontendServiceBookingUtils (same as for all other service types).
+ */
+export function foodAndBeverageQuoteCents({
+  baseRateCents,
+  headcount,
+  minimumQuantity,
+  minimumChargeCents,
+}: FoodAndBeverageQuoteParams): number {
+  if (baseRateCents <= 0 || headcount < 0) return 0;
+  const guests = quotedGuestCount(headcount, minimumQuantity);
+  const rateTotalCents = baseRateCents * guests;
+  const floorCents = minimumChargeCents ?? 0;
+  return Math.max(rateTotalCents, floorCents);
+}
+
+/**
+ * Human-readable summary string, e.g. "$18 / guest · min 25 guests".
+ */
+export function foodAndBeverageRateSummary(
+  baseRateCents: number,
+  minimumQuantity?: number | null
+): string {
+  const formatted = new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD",
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 2,
+  }).format(baseRateCents / 100);
+  const perGuest = `${formatted} / guest`;
+  if (minimumQuantity && minimumQuantity > 0) {
+    return `${perGuest} · min ${minimumQuantity} guests`;
+  }
+  return perGuest;
+}
+
+/**
+ * Return true if the entered headcount is below the listing's minimum.
+ * Use this to block checkout with a human-readable message.
+ */
+export function isBelowGuestMinimum(
+  headcount: number,
+  minimumQuantity?: number | null
+): boolean {
+  if (!minimumQuantity || minimumQuantity <= 0) return false;
+  return headcount < minimumQuantity;
+}
+
+// ---------------------------------------------------------------------------
+// Lead time
+// ---------------------------------------------------------------------------
+
+/**
+ * Human-readable lead time label, e.g. "Needs 7 days notice" or "Needs 2 weeks notice".
+ * Rounds partial weeks only when evenly divisible.
+ */
+export function foodAndBeverageLeadTimeLabel(leadTimeDays?: number | null): string | null {
+  if (!leadTimeDays || leadTimeDays <= 0) return null;
+  if (leadTimeDays % 7 === 0) {
+    const weeks = leadTimeDays / 7;
+    return `Needs ${weeks} ${weeks === 1 ? "week" : "weeks"} notice`;
+  }
+  return `Needs ${leadTimeDays} ${leadTimeDays === 1 ? "day" : "days"} notice`;
+}
+
+// ---------------------------------------------------------------------------
+// Celebration cake chips (stored on goodsOrServices with lowercase prefixes)
+// ---------------------------------------------------------------------------
+
+export const CELEBRATION_CAKE_FULFILLMENT_MODES = ["Pickup", "Delivery"] as const;
+
+export type CelebrationCakeFulfillmentMode =
+  (typeof CELEBRATION_CAKE_FULFILLMENT_MODES)[number];
+
+const CAKE_FULFILLMENT_MODE_SET: ReadonlySet<string> = new Set(
+  CELEBRATION_CAKE_FULFILLMENT_MODES
+);
+
+export function isCelebrationCakeFulfillmentMode(
+  mode: string
+): mode is CelebrationCakeFulfillmentMode {
+  return CAKE_FULFILLMENT_MODE_SET.has(mode);
+}
+
+export function filterCelebrationCakeFulfillmentModes(
+  modes?: readonly string[] | null
+): CelebrationCakeFulfillmentMode[] {
+  return (modes ?? []).filter(isCelebrationCakeFulfillmentMode);
+}
+
+export const CAKE_OPTION_KINDS = [
+  "flavor",
+  "frosting",
+  "filling",
+  "dietary",
+] as const;
+
+export type CakeOptionKind = (typeof CAKE_OPTION_KINDS)[number];
+
+export const CELEBRATION_CAKE_FLAVORS = [
+  "Vanilla",
+  "Chocolate",
+  "Red Velvet",
+  "Marble",
+  "Carrot",
+  "Lemon",
+  "Almond",
+  "Funfetti",
+  "Spice",
+  "Coconut",
+] as const;
+
+export const CELEBRATION_CAKE_FROSTINGS = [
+  "Vanilla Buttercream",
+  "Chocolate Buttercream",
+  "Cream Cheese",
+  "Whipped Cream",
+  "Fondant",
+  "Ganache",
+  "Swiss Meringue",
+] as const;
+
+export const CELEBRATION_CAKE_FILLINGS = [
+  "Raspberry",
+  "Lemon Custard",
+  "Chocolate Mousse",
+  "Strawberry",
+  "Cream Cheese",
+  "Cannoli",
+  "Vanilla Buttercream",
+] as const;
+
+export const CELEBRATION_CAKE_DIETARY = [
+  "Gluten-Free",
+  "Vegan",
+  "Nut-Free",
+  "Sugar-Free",
+  "Dairy-Free",
+] as const;
+
+export function encodeCakeOption(kind: CakeOptionKind, value: string): string {
+  return `${kind}:${value}`;
+}
+
+export interface ParsedCakeOptions {
+  flavors: string[];
+  frostings: string[];
+  fillings: string[];
+  dietary: string[];
+  other: string[];
+}
+
+/**
+ * Split prefixed cake chips back into grouped lists.
+ * Unprefixed leftovers land in `other` (caterer-style chips, if mixed).
+ */
+export function parseCakeOptions(
+  goodsOrServices?: readonly string[] | null
+): ParsedCakeOptions {
+  const result: ParsedCakeOptions = {
+    flavors: [],
+    frostings: [],
+    fillings: [],
+    dietary: [],
+    other: [],
+  };
+  if (!goodsOrServices) return result;
+
+  for (const raw of goodsOrServices) {
+    if (raw.startsWith("flavor:")) {
+      result.flavors.push(raw.slice("flavor:".length));
+    } else if (raw.startsWith("frosting:")) {
+      result.frostings.push(raw.slice("frosting:".length));
+    } else if (raw.startsWith("filling:")) {
+      result.fillings.push(raw.slice("filling:".length));
+    } else if (raw.startsWith("dietary:")) {
+      result.dietary.push(raw.slice("dietary:".length));
+    } else if (raw.length > 0) {
+      result.other.push(raw);
+    }
+  }
+  return result;
+}
+
+export function serializeCakeOptions(opts: {
+  flavors?: readonly string[];
+  frostings?: readonly string[];
+  fillings?: readonly string[];
+  dietary?: readonly string[];
+}): string[] {
+  return [
+    ...(opts.flavors ?? []).map((v) => encodeCakeOption("flavor", v)),
+    ...(opts.frostings ?? []).map((v) => encodeCakeOption("frosting", v)),
+    ...(opts.fillings ?? []).map((v) => encodeCakeOption("filling", v)),
+    ...(opts.dietary ?? []).map((v) => encodeCakeOption("dietary", v)),
+  ];
+}
+
+/**
+ * Listing line, e.g. "Cakes start at $350". Null when no starting price.
+ */
+export function celebrationCakeStartingPriceLabel(
+  minimumChargeCents?: number | null
+): string | null {
+  return startingPriceLabel("Cakes start at", minimumChargeCents);
+}
+
+function startingPriceLabel(
+  prefix: string,
+  minimumChargeCents?: number | null
+): string | null {
+  if (!minimumChargeCents || minimumChargeCents <= 0) return null;
+  const formatted = new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD",
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 2,
+  }).format(minimumChargeCents / 100);
+  return `${prefix} ${formatted}`;
+}
+
+export function grazingTableStartingPriceLabel(
+  minimumChargeCents?: number | null
+): string | null {
+  return startingPriceLabel("Boards start at", minimumChargeCents);
+}
+
+export function packagePricedFoodStartingPriceLabel(
+  eventServiceSubType?: string | null,
+  minimumChargeCents?: number | null
+): string | null {
+  if (eventServiceSubType === "GrazingTable") {
+    return grazingTableStartingPriceLabel(minimumChargeCents);
+  }
+  if (eventServiceSubType === "CelebrationCake") {
+    return celebrationCakeStartingPriceLabel(minimumChargeCents);
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Grazing / charcuterie chips (goodsOrServices with lowercase prefixes)
+// ---------------------------------------------------------------------------
+
+export const GRAZING_TABLE_FULFILLMENT_MODES = [
+  "Pickup",
+  "Delivery",
+  "FullService",
+] as const;
+
+export const GRAZING_OPTION_KINDS = ["style", "protein", "dietary"] as const;
+
+export type GrazingOptionKind = (typeof GRAZING_OPTION_KINDS)[number];
+
+export const GRAZING_TABLE_STYLES = [
+  "Classic Charcuterie",
+  "Modern Grazing",
+  "Cheese Board",
+  "Dessert Board",
+  "Breakfast Board",
+  "Seasonal",
+] as const;
+
+export const GRAZING_TABLE_PROTEINS = [
+  "Cured Meats",
+  "Artisan Cheeses",
+  "Smoked Fish",
+  "Plant-Based",
+  "Crudité",
+] as const;
+
+export const GRAZING_TABLE_DIETARY = [
+  "Gluten-Free",
+  "Vegan",
+  "Nut-Free",
+  "Dairy-Free",
+] as const;
+
+export function encodeGrazingOption(
+  kind: GrazingOptionKind,
+  value: string
+): string {
+  return `${kind}:${value}`;
+}
+
+export interface ParsedGrazingOptions {
+  styles: string[];
+  proteins: string[];
+  dietary: string[];
+  other: string[];
+}
+
+export function parseGrazingOptions(
+  goodsOrServices?: readonly string[] | null
+): ParsedGrazingOptions {
+  const result: ParsedGrazingOptions = {
+    styles: [],
+    proteins: [],
+    dietary: [],
+    other: [],
+  };
+  if (!goodsOrServices) return result;
+
+  for (const raw of goodsOrServices) {
+    if (raw.startsWith("style:")) {
+      result.styles.push(raw.slice("style:".length));
+    } else if (raw.startsWith("protein:")) {
+      result.proteins.push(raw.slice("protein:".length));
+    } else if (raw.startsWith("dietary:")) {
+      result.dietary.push(raw.slice("dietary:".length));
+    } else if (raw.length > 0) {
+      result.other.push(raw);
+    }
+  }
+  return result;
+}
+
+export function serializeGrazingOptions(opts: {
+  styles?: readonly string[];
+  proteins?: readonly string[];
+  dietary?: readonly string[];
+}): string[] {
+  return [
+    ...(opts.styles ?? []).map((v) => encodeGrazingOption("style", v)),
+    ...(opts.proteins ?? []).map((v) => encodeGrazingOption("protein", v)),
+    ...(opts.dietary ?? []).map((v) => encodeGrazingOption("dietary", v)),
+  ];
+}

package/src/utils/serviceAvailabilityDisplay.ts

@@ -30,6 +30,23 @@ export interface AvailabilityBlockedRange {
   end: Date | string;
 }
 
+/**
+ * Minimum shape needed to decide whether a service can take a bash on a
+ * calendar day. One confirmed/approved booking occupies the whole day.
+ */
+export interface ServiceDayAvailabilityInput {
+  availableHours?: unknown;
+  serviceRatesAssociation?: {
+    serviceSpecialRates?: Array<{
+      isAvailable?: boolean | null;
+      startDate?: Date | string | null;
+      endDate?: Date | string | null;
+    }> | null;
+  } | null;
+  /** Occupied ranges from Confirmed/Approved bookings (public list). */
+  bookedRanges?: readonly AvailabilityBlockedRange[] | null;
+}
+
 const WEEKDAY_NAMES = [
   "Monday",
   "Tuesday",
@@ -156,9 +173,72 @@ export function isAvailabilityDayOpen(
   return openDays[name] !== false;
 }
 
+/** Owner-blocked ranges from `ServiceSpecialRates` where `isAvailable` is false. */
+export function blockedRangesFromSpecialRates(
+  specialRates:
+    | NonNullable<
+        NonNullable<
+          ServiceDayAvailabilityInput["serviceRatesAssociation"]
+        >["serviceSpecialRates"]
+      >
+    | null
+    | undefined
+): AvailabilityBlockedRange[] {
+  if (!specialRates) return [];
+  const ranges: AvailabilityBlockedRange[] = [];
+  for (const rate of specialRates) {
+    if (rate?.isAvailable === false && rate.startDate && rate.endDate) {
+      ranges.push({ start: rate.startDate, end: rate.endDate });
+    }
+  }
+  return ranges;
+}
+
+/**
+ * True when the service can take a bash on `date`: weekly hours are open,
+ * the owner has not blocked the day, and no confirmed/approved booking
+ * already occupies it. Missing hours mean every weekday is treated as open.
+ */
+export function isServiceAvailableOnDate(
+  service: ServiceDayAvailabilityInput,
+  date: Date
+): boolean {
+  const config = parseAvailableHours(service.availableHours);
+  if (!isAvailabilityDayOpen(config?.openDays, date)) return false;
+  if (
+    isDateBlocked(
+      blockedRangesFromSpecialRates(
+        service.serviceRatesAssociation?.serviceSpecialRates
+      ),
+      date
+    )
+  ) {
+    return false;
+  }
+  if (isDateBlocked(service.bookedRanges ?? [], date)) return false;
+  return true;
+}
+
+export function filterServicesAvailableOnDate<T extends ServiceDayAvailabilityInput>(
+  services: readonly T[],
+  date: Date
+): T[] {
+  return services.filter((service) => isServiceAvailableOnDate(service, date));
+}
+
+export function countServicesAvailableOnDate<
+  T extends ServiceDayAvailabilityInput,
+>(services: readonly T[], date: Date): number {
+  let count = 0;
+  for (const service of services) {
+    if (isServiceAvailableOnDate(service, date)) count += 1;
+  }
+  return count;
+}
+
 /** Whether a date falls within any owner-blocked (unavailable) range. */
 export function isDateBlocked(
-  blockedRanges: AvailabilityBlockedRange[],
+  blockedRanges: readonly AvailabilityBlockedRange[],
   date: Date
 ): boolean {
   const day = startOfLocalDay(date).getTime();
@@ -177,7 +257,7 @@ export function isDateBlocked(
  */
 export function computeEarliestOpenDate(params: {
   openDays?: Record<string, boolean> | null;
-  blockedRanges?: AvailabilityBlockedRange[] | null;
+  blockedRanges?: readonly AvailabilityBlockedRange[] | null;
   fromDate?: Date;
   maxLookaheadDays?: number;
 }): Date | null {