@bash-app/bash-common 30.260.1 → 30.263.0

package/src/utils/service/defaultOfferAmountUtils.ts

@@ -0,0 +1,170 @@
+/**
+ * Deterministic default offer amount for a service + bash context.
+ * Keeps service cards, budget bar, SendOfferSheet prefill, and bulk offers aligned.
+ */
+import {
+  computeOfferComparisonBands,
+  type OfferComparisonInput,
+} from "./offerComparisonUtils.js";
+import {
+  resolveUnifiedPricingBlock,
+  type UnifiedPricingSourceCandidates,
+} from "./unifiedPricingResolver.js";
+import { SERVICE_DAILY_RATE_HOURS_MIN } from "./serviceRateUtils.js";
+
+export { SERVICE_DAILY_RATE_HOURS_MIN };
+
+export interface LegacyGeneralRatesShape {
+  flatRateCents?: number | null;
+  hourlyRateCents?: number | null;
+  dailyRateCents?: number | null;
+}
+
+export type DefaultOfferAmountServiceShape = UnifiedPricingSourceCandidates & {
+  serviceRatesAssociation?: {
+    serviceGeneralRates?: LegacyGeneralRatesShape | null;
+  } | null;
+};
+
+export interface DefaultOfferAmountParams {
+  service: DefaultOfferAmountServiceShape;
+  durationHours: number;
+  expectedAttendees?: number | null;
+}
+
+/** Event length in hours; defaults to 1 when dates are missing or invalid. */
+export function computeBashEventDurationHours(
+  startDateTime: Date | string | null | undefined,
+  endDateTime: Date | string | null | undefined
+): number {
+  if (!startDateTime || !endDateTime) return 1;
+  const start = new Date(startDateTime).getTime();
+  const end = new Date(endDateTime).getTime();
+  if (!Number.isFinite(start) || !Number.isFinite(end)) return 1;
+  const hours = (end - start) / (1000 * 60 * 60);
+  return hours >= 0.25 ? hours : 1;
+}
+
+/** Legacy published-rate estimate (flat → daily if 8+ hrs → hourly × duration). */
+export function calcLegacyRateEstimateCents(
+  rates: LegacyGeneralRatesShape | null | undefined,
+  durationHours: number
+): number {
+  if (!rates) return 0;
+  if ((rates.flatRateCents ?? 0) > 0) return rates.flatRateCents!;
+  const hours = durationHours >= 0.25 ? durationHours : 1;
+  if (
+    hours >= SERVICE_DAILY_RATE_HOURS_MIN &&
+    (rates.dailyRateCents ?? 0) > 0
+  ) {
+    return rates.dailyRateCents!;
+  }
+  if ((rates.hourlyRateCents ?? 0) > 0) {
+    return Math.round(rates.hourlyRateCents! * hours);
+  }
+  if ((rates.dailyRateCents ?? 0) > 0) return rates.dailyRateCents!;
+  return 0;
+}
+
+function unifiedModelEstimateCents(
+  pricingModel: string,
+  block: {
+    baseRateCents: number | null;
+    baseRateBashPoints: number | null;
+    minimumChargeCents: number | null;
+    minimumQuantity: number | null;
+  },
+  durationHours: number,
+  expectedAttendees: number | null | undefined
+): number {
+  const base = block.baseRateCents ?? 0;
+  const hours = durationHours >= 0.25 ? durationHours : 1;
+
+  switch (pricingModel) {
+    case "HOURLY":
+      return base > 0 ? Math.round(base * hours) : 0;
+    case "PER_DAY":
+      if (base <= 0) return 0;
+      if (hours >= SERVICE_DAILY_RATE_HOURS_MIN) return base;
+      return Math.round(base * (hours / SERVICE_DAILY_RATE_HOURS_MIN));
+    case "FLAT_FEE":
+    case "CUSTOM":
+      return base > 0 ? base : 0;
+    case "PER_ATTENDEE":
+    case "PER_PAID_ATTENDEE": {
+      const bands = computeOfferComparisonBands({
+        pricingModel,
+        baseRateCents: base,
+        minimumChargeCents: block.minimumChargeCents,
+        minimumQuantity: block.minimumQuantity,
+        expectedAttendees,
+      } satisfies OfferComparisonInput);
+      return bands.expectedTotalCents ?? 0;
+    }
+    case "PER_BASHPOINTS_ATTENDEE":
+      return 0;
+    case "TIERED": {
+      const bands = computeOfferComparisonBands({
+        pricingModel: "TIERED",
+        tieredExpectedTierCents: base > 0 ? base : null,
+      });
+      return bands.expectedTotalCents ?? 0;
+    }
+    default: {
+      const bands = computeOfferComparisonBands({
+        pricingModel,
+        baseRateCents: base,
+        flatRateCents: base > 0 ? base : null,
+      });
+      return bands.expectedTotalCents ?? 0;
+    }
+  }
+}
+
+/**
+ * Returns the suggested opening offer in USD cents for this bash, or 0 when
+ * no computable rate exists (bulk send should skip those services).
+ */
+export function getDefaultOfferAmountCents(
+  params: DefaultOfferAmountParams
+): number {
+  const { service, durationHours, expectedAttendees } = params;
+  const legacyRates = service.serviceRatesAssociation?.serviceGeneralRates;
+
+  const block = resolveUnifiedPricingBlock({
+    eventService: service.eventService,
+    vendor: service.vendor,
+    exhibitor: service.exhibitor,
+    sponsor: service.sponsor,
+    venue: service.venue,
+    entertainmentService: service.entertainmentService,
+    volunteerService: service.volunteerService,
+    legacyRate: null,
+  });
+
+  if (block.fromUnifiedBlock && block.pricingModel) {
+    const unified = unifiedModelEstimateCents(
+      block.pricingModel,
+      block,
+      durationHours,
+      expectedAttendees
+    );
+    if (unified > 0) return unified;
+  }
+
+  return calcLegacyRateEstimateCents(legacyRates, durationHours);
+}
+
+export function formatOfferAmountDollars(cents: number): string {
+  return `$${Math.round(cents / 100).toLocaleString("en-US")}`;
+}
+
+/** Host → provider bulk offers only when a positive USD default exists. */
+export function isBulkHostOfferEligible(
+  amountCents: number,
+  isParticipationFeeService: boolean
+): boolean {
+  return !isParticipationFeeService && amountCents > 0;
+}
+
+export const BULK_OFFER_MAX_COUNT = 10;

package/src/utils/ticketTierSchedule.ts

@@ -0,0 +1,387 @@
+/**
+ * Ticket tier release / expiry / sold-out schedule resolver — shared by API + bash-app.
+ */
+
+import type { TicketTierAvailability } from "../definitions.js";
+
+export type PreReleaseDisplay = "Tease" | "Hidden";
+
+export type PresaleAudience = "Public" | "Ambashador" | "BashInsider" | "Promoters";
+
+export type TicketTierSchedulePhase =
+  | "HostHidden"
+  | "HiddenPreRelease"
+  | "TeasePreRelease"
+  | "Live"
+  | "Expired"
+  | "SoldOut";
+
+export type TicketTierScheduleInput = {
+  availabilityType?: string | null;
+  availableAt?: Date | string | null;
+  expiresAt?: Date | string | null;
+  preReleaseDisplay?: string | null;
+  hidden?: boolean | null;
+  isManuallySoldOut?: boolean | null;
+  isWaitlistTier?: boolean | null;
+  availabilityTypeUnlock?: string | null;
+  availableWhenInterestReached?: number | null;
+  unlockWhenTicketsSold?: number | null;
+  presaleAudience?: string | null;
+  publicAvailableAt?: Date | string | null;
+};
+
+export type TicketTierScheduleContext = {
+  now?: Date;
+  availableInventory?: number;
+  ideaInterestCount?: number;
+  ticketsSoldCount?: number;
+  isViewerEngaged?: boolean;
+  isViewerAmbashador?: boolean;
+  isViewerBashInsider?: boolean;
+  isViewerPromoterForEvent?: boolean;
+};
+
+export type TicketTierScheduleState = {
+  phase: TicketTierSchedulePhase;
+  availableAt: string | null;
+  expiresAt: string | null;
+  canPurchase: boolean;
+  soldOut: boolean;
+  showWaitlistCta: boolean;
+  guestVisible: boolean;
+  availability: TicketTierAvailability;
+  hostPreviewLabel: string;
+};
+
+export type ScheduleValidationIssue = {
+  field: string;
+  message: string;
+  severity: "error" | "warn";
+};
+
+function toDate(value: Date | string | null | undefined): Date | null {
+  if (value == null) return null;
+  const d = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+
+function toIso(value: Date | string | null | undefined): string | null {
+  const d = toDate(value);
+  return d ? d.toISOString() : null;
+}
+
+function normalizePreReleaseDisplay(value: string | null | undefined): PreReleaseDisplay {
+  return value === "Hidden" ? "Hidden" : "Tease";
+}
+
+function isOnDate(type: string | null | undefined): boolean {
+  return type === "OnDate";
+}
+
+function isPresaleAudienceEligible(
+  audience: string | null | undefined,
+  ctx: TicketTierScheduleContext
+): boolean {
+  switch (audience) {
+    case "Ambashador":
+      return ctx.isViewerAmbashador === true;
+    case "BashInsider":
+      return ctx.isViewerBashInsider === true;
+    case "Promoters":
+      return ctx.isViewerPromoterForEvent === true;
+    default:
+      return true;
+  }
+}
+
+function resolveUnlockAvailability(
+  tier: TicketTierScheduleInput,
+  ctx: TicketTierScheduleContext
+): TicketTierAvailability | null {
+  const type = tier.availabilityType ?? "Immediate";
+  if (type === "UnlockWhenInterestReached") {
+    const threshold = tier.availableWhenInterestReached ?? 0;
+    const count = ctx.ideaInterestCount ?? 0;
+    const available = count >= threshold;
+    return {
+      available,
+      reason: "UnlockWhenInterestReached",
+      interestCount: count,
+      interestThreshold: threshold,
+    };
+  }
+  if (type === "UnlockWhenTicketsSold") {
+    const threshold = tier.unlockWhenTicketsSold ?? 0;
+    const count = ctx.ticketsSoldCount ?? 0;
+    const available = count >= threshold;
+    return {
+      available,
+      reason: "UnlockWhenTicketsSold",
+      ticketsSoldCount: count,
+      ticketsSoldThreshold: threshold,
+    };
+  }
+  return null;
+}
+
+/**
+ * Resolve guest-visible phase and purchase eligibility for a ticket tier.
+ */
+export function resolveTicketTierScheduleState(
+  tier: TicketTierScheduleInput,
+  ctx: TicketTierScheduleContext = {}
+): TicketTierScheduleState {
+  const now = ctx.now ?? new Date();
+  const availableAt = toDate(tier.availableAt);
+  const expiresAt = toDate(tier.expiresAt);
+  const publicAvailableAt = toDate(tier.publicAvailableAt);
+  const inventory = ctx.availableInventory;
+  const manualSoldOut = tier.isManuallySoldOut === true;
+  /** Only treat as inventory sold-out when callers supply a count — unknown ≠ zero. */
+  const soldOut =
+    manualSoldOut || (inventory !== undefined && inventory <= 0);
+  const preDisplay = normalizePreReleaseDisplay(tier.preReleaseDisplay);
+  const type = tier.availabilityType ?? "Immediate";
+
+  if (tier.hidden) {
+    return buildState({
+      phase: "HostHidden",
+      availableAt,
+      expiresAt,
+      canPurchase: false,
+      soldOut,
+      isWaitlistTier: tier.isWaitlistTier,
+      availability: { available: false },
+      hostPreviewLabel: "Hidden by host",
+    });
+  }
+
+  if (expiresAt && now >= expiresAt) {
+    return buildState({
+      phase: "Expired",
+      availableAt,
+      expiresAt,
+      canPurchase: false,
+      soldOut,
+      isWaitlistTier: tier.isWaitlistTier,
+      availability: { available: false },
+      hostPreviewLabel: "Expired",
+    });
+  }
+
+  const unlockAvail = resolveUnlockAvailability(tier, ctx);
+  if (unlockAvail && !unlockAvail.available) {
+    return buildState({
+      phase: type === "OnDate" && availableAt && now < availableAt
+        ? preDisplay === "Hidden" ? "HiddenPreRelease" : "TeasePreRelease"
+        : "TeasePreRelease",
+      availableAt,
+      expiresAt,
+      canPurchase: false,
+      soldOut,
+      isWaitlistTier: tier.isWaitlistTier,
+      availability: unlockAvail,
+      hostPreviewLabel: "Unlock pending",
+    });
+  }
+
+  if (isOnDate(type) && availableAt && now < availableAt) {
+    const phase: TicketTierSchedulePhase =
+      preDisplay === "Hidden" ? "HiddenPreRelease" : "TeasePreRelease";
+    return buildState({
+      phase,
+      availableAt,
+      expiresAt,
+      canPurchase: false,
+      soldOut,
+      isWaitlistTier: tier.isWaitlistTier,
+      availability: {
+        available: false,
+        reason: "OnDate",
+        availableAt: availableAt.toISOString(),
+      },
+      hostPreviewLabel: phase === "HiddenPreRelease" ? "Hidden until release" : "Tease + countdown",
+    });
+  }
+
+  const presaleAudience = tier.presaleAudience ?? "Public";
+  if (presaleAudience !== "Public") {
+    const publicOpensAt = publicAvailableAt ?? availableAt;
+    const presaleOpen = !availableAt || now >= availableAt;
+    const publicOpen = !publicOpensAt || now >= publicOpensAt;
+    const eligible = isPresaleAudienceEligible(presaleAudience, ctx);
+    if (!publicOpen && (!presaleOpen || !eligible)) {
+      return buildState({
+        phase: presaleOpen && !publicOpen ? "TeasePreRelease" : "HiddenPreRelease",
+        availableAt: publicOpensAt ?? availableAt,
+        expiresAt,
+        canPurchase: false,
+        soldOut,
+        isWaitlistTier: tier.isWaitlistTier,
+        availability: {
+          available: false,
+          reason: "OnDate",
+          availableAt: (publicOpensAt ?? availableAt)?.toISOString(),
+        },
+        hostPreviewLabel: `${presaleAudience} presale`,
+      });
+    }
+    if (presaleOpen && !publicOpen && !eligible) {
+      return buildState({
+        phase: "TeasePreRelease",
+        availableAt: publicOpensAt,
+        expiresAt,
+        canPurchase: false,
+        soldOut,
+        isWaitlistTier: tier.isWaitlistTier,
+        availability: {
+          available: false,
+          reason: "OnDate",
+          availableAt: publicOpensAt?.toISOString(),
+        },
+        hostPreviewLabel: "Public sale scheduled",
+      });
+    }
+  }
+
+  if (type === "EngagedUsersOnly" && ctx.isViewerEngaged === false) {
+    return buildState({
+      phase: soldOut ? "SoldOut" : "Live",
+      availableAt,
+      expiresAt,
+      canPurchase: false,
+      soldOut,
+      isWaitlistTier: tier.isWaitlistTier,
+      availability: {
+        available: false,
+        reason: "EngagedUsersOnly",
+        isViewerEngaged: false,
+      },
+      hostPreviewLabel: soldOut ? "Sold out" : "RSVP required",
+    });
+  }
+
+  if (soldOut) {
+    return buildState({
+      phase: "SoldOut",
+      availableAt,
+      expiresAt,
+      canPurchase: false,
+      soldOut: true,
+      isWaitlistTier: tier.isWaitlistTier,
+      availability: { available: false },
+      hostPreviewLabel: manualSoldOut ? "Sold out (manual)" : "Sold out",
+    });
+  }
+
+  const availability: TicketTierAvailability = unlockAvail ?? { available: true };
+  if (type === "EngagedUsersOnly") {
+    availability.reason = "EngagedUsersOnly";
+    availability.isViewerEngaged = ctx.isViewerEngaged;
+  }
+
+  return buildState({
+    phase: "Live",
+    availableAt,
+    expiresAt,
+    canPurchase: true,
+    soldOut: false,
+    isWaitlistTier: tier.isWaitlistTier,
+    availability,
+    hostPreviewLabel: "Live",
+  });
+}
+
+function buildState(args: {
+  phase: TicketTierSchedulePhase;
+  availableAt: Date | null;
+  expiresAt: Date | null;
+  canPurchase: boolean;
+  soldOut: boolean;
+  isWaitlistTier?: boolean | null;
+  availability: TicketTierAvailability;
+  hostPreviewLabel: string;
+}): TicketTierScheduleState {
+  const guestVisible =
+    args.phase !== "HostHidden" &&
+    args.phase !== "HiddenPreRelease" &&
+    args.phase !== "Expired";
+  return {
+    phase: args.phase,
+    availableAt: toIso(args.availableAt),
+    expiresAt: toIso(args.expiresAt),
+    canPurchase: args.canPurchase,
+    soldOut: args.soldOut,
+    showWaitlistCta: args.soldOut && args.isWaitlistTier === true,
+    guestVisible,
+    availability: args.availability,
+    hostPreviewLabel: args.hostPreviewLabel,
+  };
+}
+
+export function validateTicketTierScheduleInput(
+  tier: TicketTierScheduleInput,
+  bashEvent?: { startDateTime?: Date | string | null }
+): ScheduleValidationIssue[] {
+  const issues: ScheduleValidationIssue[] = [];
+  const type = tier.availabilityType ?? "Immediate";
+  const availableAt = toDate(tier.availableAt);
+  const expiresAt = toDate(tier.expiresAt);
+  const start = bashEvent ? toDate(bashEvent.startDateTime) : null;
+
+  if (isOnDate(type) && !availableAt) {
+    issues.push({
+      field: "availableAt",
+      message: "Release date and time are required when scheduling a tier.",
+      severity: "error",
+    });
+  }
+
+  if (availableAt && expiresAt && expiresAt <= availableAt) {
+    issues.push({
+      field: "expiresAt",
+      message: "Expires must be after the release time.",
+      severity: "error",
+    });
+  }
+
+  if (expiresAt && expiresAt <= new Date()) {
+    issues.push({
+      field: "expiresAt",
+      message: "Expires must be in the future.",
+      severity: "error",
+    });
+  }
+
+  if (start && availableAt && availableAt > start) {
+    issues.push({
+      field: "availableAt",
+      message: "Release is after the event start — double-check the time.",
+      severity: "warn",
+    });
+  }
+
+  if (start && expiresAt && expiresAt > start) {
+    issues.push({
+      field: "expiresAt",
+      message: "Tier expires after the event starts — unusual but allowed.",
+      severity: "warn",
+    });
+  }
+
+  return issues;
+}
+
+export function scheduleValidationHasErrors(issues: ScheduleValidationIssue[]): boolean {
+  return issues.some((i) => i.severity === "error");
+}
+
+/** Whether tier should appear on guest detail ticket list (incl. tease). */
+export function isTicketTierGuestListVisible(state: TicketTierScheduleState): boolean {
+  return (
+    state.guestVisible ||
+    state.phase === "TeasePreRelease" ||
+    state.phase === "SoldOut"
+  );
+}