@bash-app/bash-common 30.260.1 → 30.263.0

package/src/utils/featuredDiscoveryGeo.ts

@@ -0,0 +1,75 @@
+/** Default featured-discovery radius when the client omits `featuredRadiusMiles`. */
+export const DEFAULT_FEATURED_RADIUS_MILES = 200;
+
+/**
+ * Haversine distance in miles between two WGS84 points.
+ */
+export function haversineMiles(
+  lat1: number,
+  lng1: number,
+  lat2: number,
+  lng2: number
+): number {
+  const R = 3958.8;
+  const dLat = ((lat2 - lat1) * Math.PI) / 180;
+  const dLng = ((lng2 - lng1) * Math.PI) / 180;
+  const a =
+    Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+    Math.cos((lat1 * Math.PI) / 180) *
+      Math.cos((lat2 * Math.PI) / 180) *
+      Math.sin(dLng / 2) *
+      Math.sin(dLng / 2);
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  return R * c;
+}
+
+export interface ViewerGeoScope {
+  lat: number;
+  lng: number;
+  radiusMiles: number;
+}
+
+export function effectiveFeaturedForGeoScope(
+  isFeatured: boolean,
+  coordinates: Array<{ lat: number | null; lng: number | null }> | null | undefined,
+  viewer: ViewerGeoScope | undefined
+): boolean {
+  if (!isFeatured) return false;
+  if (!viewer) return true;
+  const first = coordinates?.find((c) => c.lat != null && c.lng != null);
+  if (!first || first.lat == null || first.lng == null) return false;
+  const d = haversineMiles(first.lat, first.lng, viewer.lat, viewer.lng);
+  return d <= viewer.radiusMiles;
+}
+
+export type EventWithFeaturedAndCoords = {
+  id: string;
+  isFeatured: boolean | null;
+  featuredUntil?: Date | null;
+  startDateTime: Date | string | null;
+  coordinates?: Array<{ lat: number | null; lng: number | null }> | null;
+};
+
+/**
+ * Sort: effective featured (in geo scope if viewer set) first, then by startDateTime.
+ */
+export function sortPublicEventsForFeaturedDiscovery<
+  T extends EventWithFeaturedAndCoords,
+>(events: T[], viewer: ViewerGeoScope | undefined): T[] {
+  const withKeys = events.map((e) => {
+    const eff = effectiveFeaturedForGeoScope(
+      !!e.isFeatured,
+      e.coordinates,
+      viewer
+    );
+    const start = e.startDateTime
+      ? new Date(e.startDateTime as Date | string).getTime()
+      : 0;
+    return { e, eff, start };
+  });
+  withKeys.sort((a, b) => {
+    if (a.eff !== b.eff) return (b.eff ? 1 : 0) - (a.eff ? 1 : 0);
+    return a.start - b.start;
+  });
+  return withKeys.map((x) => x.e);
+}

package/src/utils/flyerUtils.ts

@@ -158,6 +158,39 @@ export function computeHostTotalAfterSponsors(
   return Math.max(0, printPostageCostCents - sponsorRevenueCents);
 }
 
+/** Default slot price in cents for Featured vs Supporting flyer slots. */
+export function flyerSponsorSlotPriceCents(
+  slot: "FEATURED" | "SUPPORTING_1" | "SUPPORTING_2",
+  requestedPrice?: number
+): number {
+  if (requestedPrice != null) return requestedPrice;
+  return slot === "FEATURED"
+    ? FLYER_SPONSOR_DEFAULT_FEATURED_CENTS
+    : FLYER_SPONSOR_DEFAULT_SUPPORTING_CENTS;
+}
+
+/** Host revenue share for a flyer sponsor slot. */
+export function flyerSponsorSlotHostPct(
+  slot: "FEATURED" | "SUPPORTING_1" | "SUPPORTING_2"
+): number {
+  return slot === "FEATURED" ? 0.6 : 0.65;
+}
+
+export function flyerSponsorSlotLabel(
+  slot: "FEATURED" | "SUPPORTING_1" | "SUPPORTING_2"
+): string {
+  switch (slot) {
+    case "FEATURED":
+      return "Featured";
+    case "SUPPORTING_1":
+      return "Supporting 1";
+    case "SUPPORTING_2":
+      return "Supporting 2";
+    default:
+      return slot;
+  }
+}
+
 const EARTH_RADIUS_MI = 3958.8;
 
 /** Haversine distance in miles between two WGS84 points. */

package/src/utils/guestSurface.ts

@@ -0,0 +1,315 @@
+/**
+ * Curated guest visibility — shared policy resolver for API + bash-app.
+ * Three layers compose: event teaser policy, per-guest visibility, viewer roster depth.
+ */
+
+import type { PublicTeaserUser } from "../extendedSchemas.js";
+
+export type AttendeeDisplayMode =
+  | "All"
+  | "CountOnly"
+  | "NetworkOnly"
+  | "Hidden";
+
+export type AttendeeVisibility =
+  | "Visible"
+  | "Hidden"
+  | "FeaturedPending"
+  | "FeaturedInvited";
+
+export type GuestListDepth = "None" | "Partial" | "Full";
+
+export type { PublicTeaserUser };
+
+export type NetworkOverlapPayload = {
+  connections: PublicTeaserUser[];
+  contacts: PublicTeaserUser[];
+  customLists: Array<{
+    listId: string;
+    listName: string;
+    users: PublicTeaserUser[];
+  }>;
+};
+
+export type GuestSurfacePayload = {
+  count: { totalTickets: number; visibleAttendees: number };
+  preview: PublicTeaserUser[];
+  featured: PublicTeaserUser[];
+  featuredHeadline: string | null;
+  network: NetworkOverlapPayload | null;
+  upsell: { hasDeeperTiers: boolean; cheapestTierName?: string } | null;
+  roster?: {
+    users: PublicTeaserUser[];
+    totalVisible: number;
+    hasMore: boolean;
+    cursor?: string;
+  };
+  viewer: { rosterDepth: GuestListDepth; isHost: boolean };
+  policy: { effectiveMode: AttendeeDisplayMode };
+  /** Host-only: user IDs awaiting spotlight approval (guest-initiated) */
+  pendingFeaturedUserIds?: string[];
+  /** Host-only: user IDs with host-initiated featured invite pending accept */
+  pendingFeaturedInviteUserIds?: string[];
+  /** Viewer-only: pending featured invite for the authenticated viewer */
+  viewerFeaturedInvite?: {
+    bashEventId: string;
+    bashTitle: string;
+    hostName?: string;
+  } | null;
+  /** Host-only: per-guest visibility for roster management */
+  attendeeVisibilityByUserId?: Record<string, AttendeeVisibility>;
+  /** Event has public guest list enabled on bash detail */
+  attendeeListPublic?: boolean;
+};
+
+export type AttendeeRosterMeta = {
+  depth: GuestListDepth;
+  totalVisible?: number;
+  hasMore?: boolean;
+  cursor?: string;
+};
+
+export type EventModeInput = {
+  attendeeDisplayMode?: string | null;
+  showAttendees?: boolean | null;
+};
+
+export type GuestSurfacePolicyInput = {
+  eventMode: AttendeeDisplayMode;
+  isHost: boolean;
+  isAuthenticated: boolean;
+  viewerRosterDepth: GuestListDepth;
+};
+
+export type GuestSurfacePolicy = {
+  showCount: boolean;
+  showPreviewAvatars: boolean;
+  showFeatured: boolean;
+  showNetworkSlice: boolean;
+  rosterDepth: GuestListDepth;
+  previewLimit: number;
+  apiPreviewLimit: number;
+  effectiveMode: AttendeeDisplayMode;
+};
+
+const DEPTH_RANK: Record<GuestListDepth, number> = {
+  None: 0,
+  Partial: 1,
+  Full: 2,
+};
+
+/** Legacy showAttendees=false → Hidden; otherwise honour attendeeDisplayMode string. */
+export function resolveEffectiveEventMode(
+  event: EventModeInput
+): AttendeeDisplayMode {
+  const raw = event.attendeeDisplayMode;
+  if (raw === "CountOnly") return "CountOnly";
+  if (raw === "NetworkOnly") return "NetworkOnly";
+  if (raw === "Hidden") return "Hidden";
+  if (event.showAttendees === false) return "Hidden";
+  return "All";
+}
+
+export function compareGuestListDepth(
+  a: GuestListDepth,
+  b: GuestListDepth
+): number {
+  return DEPTH_RANK[a] - DEPTH_RANK[b];
+}
+
+export function maxGuestListDepth(
+  ...depths: GuestListDepth[]
+): GuestListDepth {
+  if (depths.length === 0) return "None";
+  return depths.reduce((max, d) =>
+    compareGuestListDepth(d, max) > 0 ? d : max
+  );
+}
+
+/** Cap viewer tier depth by event mode for non-hosts. */
+export function capRosterDepthForEventMode(
+  viewerDepth: GuestListDepth,
+  eventMode: AttendeeDisplayMode,
+  isHost: boolean
+): GuestListDepth {
+  if (isHost) return "Full";
+  if (eventMode === "Hidden") return "None";
+  if (eventMode === "NetworkOnly") return "None";
+  return viewerDepth;
+}
+
+/** Whether the viewer may fetch the full host-style roster endpoint. */
+export function viewerMayFetchFullRoster(input: {
+  isHost: boolean;
+  viewerRosterDepth: GuestListDepth;
+}): boolean {
+  if (input.isHost) return true;
+  return compareGuestListDepth(input.viewerRosterDepth, "Partial") >= 0;
+}
+
+/** Public bash-detail teaser policy (Layer 1 + viewer depth cap). */
+export function resolveGuestSurfacePolicy(
+  input: GuestSurfacePolicyInput
+): GuestSurfacePolicy {
+  const { eventMode, isHost, isAuthenticated, viewerRosterDepth } = input;
+  const effectiveDepth = capRosterDepthForEventMode(
+    viewerRosterDepth,
+    eventMode,
+    isHost
+  );
+
+  if (eventMode === "Hidden" && !isHost) {
+    return {
+      showCount: false,
+      showPreviewAvatars: false,
+      showFeatured: false,
+      showNetworkSlice: false,
+      rosterDepth: "None",
+      previewLimit: 4,
+      apiPreviewLimit: 10,
+      effectiveMode: eventMode,
+    };
+  }
+
+  if (eventMode === "CountOnly" && !isHost) {
+    return {
+      showCount: true,
+      showPreviewAvatars: false,
+      showFeatured: false,
+      showNetworkSlice: isAuthenticated,
+      rosterDepth: effectiveDepth,
+      previewLimit: 4,
+      apiPreviewLimit: 10,
+      effectiveMode: eventMode,
+    };
+  }
+
+  const showCount = true;
+  const showPreviewAvatars =
+    eventMode === "All" && !isHost
+      ? true
+      : eventMode === "All" && isHost
+        ? true
+        : false;
+  const showFeatured =
+    (eventMode === "All" || isHost) && eventMode !== "CountOnly";
+  const showNetworkSlice =
+    isAuthenticated &&
+    (eventMode === "All" ||
+      eventMode === "CountOnly" ||
+      eventMode === "NetworkOnly" ||
+      isHost);
+
+  return {
+    showCount,
+    showPreviewAvatars:
+      showPreviewAvatars &&
+      eventMode !== "CountOnly" &&
+      eventMode !== "NetworkOnly",
+    showFeatured: showFeatured && eventMode !== "NetworkOnly",
+    showNetworkSlice,
+    rosterDepth: effectiveDepth,
+    previewLimit: 4,
+    apiPreviewLimit: 10,
+    effectiveMode: eventMode,
+  };
+}
+
+export type PreviewAttendeeRow = {
+  userId: string;
+  paidOn?: Date | string | null;
+  checkedInAt?: Date | string | null;
+};
+
+/** Featured first, then most recent activity, then stable userId. */
+export function orderPreviewAttendeeIds(
+  rows: PreviewAttendeeRow[],
+  featuredUserIds: string[],
+  limit: number
+): string[] {
+  const featuredSet = new Set(featuredUserIds);
+  const byUser = new Map<string, PreviewAttendeeRow>();
+  for (const row of rows) {
+    if (!row.userId) continue;
+    const existing = byUser.get(row.userId);
+    if (!existing) {
+      byUser.set(row.userId, row);
+      continue;
+    }
+    const existingTs = activityTimestamp(existing);
+    const rowTs = activityTimestamp(row);
+    if (rowTs > existingTs) byUser.set(row.userId, row);
+  }
+
+  const featuredOrdered = featuredUserIds.filter((id) => byUser.has(id));
+  const rest = [...byUser.entries()]
+    .filter(([id]) => !featuredSet.has(id))
+    .sort(([, a], [, b]) => {
+      const diff = activityTimestamp(b) - activityTimestamp(a);
+      if (diff !== 0) return diff;
+      return a.userId.localeCompare(b.userId);
+    })
+    .map(([id]) => id);
+
+  return [...featuredOrdered, ...rest].slice(0, limit);
+}
+
+function activityTimestamp(row: PreviewAttendeeRow): number {
+  const paid =
+    row.paidOn != null ? new Date(row.paidOn as string | Date).getTime() : 0;
+  const checked =
+    row.checkedInAt != null
+      ? new Date(row.checkedInAt as string | Date).getTime()
+      : 0;
+  return Math.max(paid, checked);
+}
+
+export function filterHiddenVisibilityUserIds(
+  userIds: string[],
+  visibilityByUserId: Map<string, AttendeeVisibility>,
+  isHost: boolean
+): string[] {
+  if (isHost) return userIds;
+  return userIds.filter((id) => {
+    const v = visibilityByUserId.get(id) ?? "Visible";
+    return v === "Visible" || v === "FeaturedPending";
+    // FeaturedInvited is hidden until the guest accepts
+  });
+}
+
+export function filterBlockedUserIds(
+  userIds: string[],
+  blockedIds: Set<string>
+): string[] {
+  return userIds.filter((id) => !blockedIds.has(id));
+}
+
+export function guestListDepthFromTierField(
+  value: string | null | undefined
+): GuestListDepth {
+  if (value === "Partial" || value === "Full") return value;
+  return "None";
+}
+
+export function computeUpsellFromTiers(
+  tiers: Array<{ guestListDepth?: string | null; title?: string | null; price?: number | null }>,
+  viewerDepth: GuestListDepth
+): GuestSurfacePayload["upsell"] {
+  const deeper = tiers.filter(
+    (t) =>
+      compareGuestListDepth(
+        guestListDepthFromTierField(t.guestListDepth),
+        "None"
+      ) > 0
+  );
+  if (deeper.length === 0 || compareGuestListDepth(viewerDepth, "Partial") >= 0) {
+    return null;
+  }
+  const sorted = [...deeper].sort(
+    (a, b) => (a.price ?? 0) - (b.price ?? 0)
+  );
+  return {
+    hasDeeperTiers: true,
+    cheapestTierName: sorted[0]?.title ?? undefined,
+  };
+}

package/src/utils/promotionBlastUtils.ts

@@ -0,0 +1,127 @@
+/**
+ * Promotion Blast — on-site partner promos (time-boxed + geofence).
+ */
+
+export type PromotionBlastPackageTierId = "starter" | "standard" | "premium";
+
+export type PromotionBlastTriggerTypeId = "TIME_BOXED" | "GEOFENCE";
+
+export interface PromotionBlastPackageTerms {
+  tierId: PromotionBlastPackageTierId;
+  maxBlasts: number;
+  maxPushRecipients?: number | null;
+  maxRadiusFeet: number;
+  allowedTriggerTypes: PromotionBlastTriggerTypeId[];
+  hostAccessFeeCents: number;
+  bashPlatformFeeCents: number;
+  templateId?: string | null;
+}
+
+/** Minutes before event start when partners may activate blasts. */
+export const PROMOTION_BLAST_EVENT_WINDOW_BEFORE_MINUTES = 30;
+
+/** Minutes after event end when partners may still activate. */
+export const PROMOTION_BLAST_EVENT_WINDOW_AFTER_MINUTES = 30;
+
+/** Max concurrently live partner promos per event. */
+export const PROMOTION_BLAST_MAX_LIVE_PER_EVENT = 5;
+
+/** Max promotional pushes per attendee per event (all partners). */
+export const PROMOTION_BLAST_MAX_PUSHES_PER_USER_PER_EVENT = 3;
+
+/** Min minutes between promo pushes to same user at same event. */
+export const PROMOTION_BLAST_MIN_PUSH_INTERVAL_MINUTES = 15;
+
+export const PROMOTION_BLAST_HEADLINE_MAX_LENGTH = 80;
+export const PROMOTION_BLAST_BODY_MAX_LENGTH = 280;
+export const PROMOTION_BLAST_CTA_MAX_LENGTH = 40;
+
+export const PROMOTION_BLAST_DURATION_PRESETS_MINUTES = [15, 30, 60] as const;
+export const PROMOTION_BLAST_RADIUS_PRESETS_FEET = [100, 200, 500] as const;
+
+export const PROMOTION_BLAST_PACKAGES: Record<
+  PromotionBlastPackageTierId,
+  Omit<PromotionBlastPackageTerms, "hostAccessFeeCents" | "templateId">
+> = {
+  starter: {
+    tierId: "starter",
+    maxBlasts: 1,
+    maxPushRecipients: null,
+    maxRadiusFeet: 200,
+    allowedTriggerTypes: ["TIME_BOXED"],
+    bashPlatformFeeCents: 500,
+  },
+  standard: {
+    tierId: "standard",
+    maxBlasts: 3,
+    maxPushRecipients: null,
+    maxRadiusFeet: 500,
+    allowedTriggerTypes: ["TIME_BOXED", "GEOFENCE"],
+    bashPlatformFeeCents: 1200,
+  },
+  premium: {
+    tierId: "premium",
+    maxBlasts: 999,
+    maxPushRecipients: null,
+    maxRadiusFeet: 500,
+    allowedTriggerTypes: ["TIME_BOXED", "GEOFENCE"],
+    bashPlatformFeeCents: 2500,
+  },
+};
+
+export function promotionBlastPackageForTier(
+  tierId: PromotionBlastPackageTierId,
+  hostAccessFeeCents: number,
+  templateId?: string | null
+): PromotionBlastPackageTerms {
+  const base = PROMOTION_BLAST_PACKAGES[tierId];
+  return {
+    ...base,
+    hostAccessFeeCents,
+    templateId: templateId ?? null,
+  };
+}
+
+export function promotionBlastPackageTotalCents(pkg: PromotionBlastPackageTerms): number {
+  return pkg.hostAccessFeeCents + pkg.bashPlatformFeeCents;
+}
+
+export function promotionBlastPackageLabel(tierId: PromotionBlastPackageTierId): string {
+  switch (tierId) {
+    case "starter":
+      return "Starter — 1 time-boxed blast";
+    case "standard":
+      return "Standard — 3 blasts + geofence";
+    case "premium":
+      return "Premium — unlimited blasts + geofence";
+    default:
+      return tierId;
+  }
+}
+
+export function isWithinPromotionBlastEventWindow(
+  eventStart: Date,
+  eventEnd: Date | null | undefined,
+  now: Date = new Date()
+): boolean {
+  const windowStart = new Date(eventStart);
+  windowStart.setMinutes(windowStart.getMinutes() - PROMOTION_BLAST_EVENT_WINDOW_BEFORE_MINUTES);
+  const windowEnd = eventEnd
+    ? new Date(eventEnd)
+    : new Date(eventStart.getTime() + 4 * 60 * 60 * 1000);
+  windowEnd.setMinutes(windowEnd.getMinutes() + PROMOTION_BLAST_EVENT_WINDOW_AFTER_MINUTES);
+  return now >= windowStart && now <= windowEnd;
+}
+
+export function generatePromotionBlastConfirmationCode(): string {
+  const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+  let code = "";
+  for (let i = 0; i < 6; i++) {
+    code += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return code;
+}
+
+export function promotionBlastDeepLinkPath(bashEventId: string, blastId: string): string {
+  return `/bash/${encodeURIComponent(bashEventId)}?tab=promotions&blast=${encodeURIComponent(blastId)}`;
+}

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

@@ -0,0 +1,102 @@
+import {
+  calcLegacyRateEstimateCents,
+  computeBashEventDurationHours,
+  getDefaultOfferAmountCents,
+  isBulkHostOfferEligible,
+} from "../defaultOfferAmountUtils.js";
+
+describe("calcLegacyRateEstimateCents", () => {
+  it("uses flat rate when set", () => {
+    expect(
+      calcLegacyRateEstimateCents({ flatRateCents: 50_000 }, 4)
+    ).toBe(50_000);
+  });
+
+  it("uses daily rate for 8+ hour events", () => {
+    expect(
+      calcLegacyRateEstimateCents(
+        { hourlyRateCents: 15_000, dailyRateCents: 50_000 },
+        8
+      )
+    ).toBe(50_000);
+  });
+
+  it("uses hourly × duration for shorter events", () => {
+    expect(
+      calcLegacyRateEstimateCents(
+        { hourlyRateCents: 15_000, dailyRateCents: 50_000 },
+        4
+      )
+    ).toBe(60_000);
+  });
+});
+
+describe("computeBashEventDurationHours", () => {
+  it("returns hours between start and end", () => {
+    expect(
+      computeBashEventDurationHours(
+        "2026-06-01T18:00:00.000Z",
+        "2026-06-01T22:00:00.000Z"
+      )
+    ).toBe(4);
+  });
+
+  it("defaults to 1 when dates missing", () => {
+    expect(computeBashEventDurationHours(null, null)).toBe(1);
+  });
+});
+
+describe("getDefaultOfferAmountCents", () => {
+  it("prefers unified HOURLY model with duration", () => {
+    expect(
+      getDefaultOfferAmountCents({
+        service: {
+          entertainmentService: {
+            pricingModel: "HOURLY",
+            baseRateCents: 20_000,
+          },
+        },
+        durationHours: 3,
+      })
+    ).toBe(60_000);
+  });
+
+  it("falls back to legacy general rates", () => {
+    expect(
+      getDefaultOfferAmountCents({
+        service: {
+          serviceRatesAssociation: {
+            serviceGeneralRates: { dailyRateCents: 75_000 },
+          },
+        },
+        durationHours: 10,
+      })
+    ).toBe(75_000);
+  });
+
+  it("computes PER_ATTENDEE from expected guests", () => {
+    expect(
+      getDefaultOfferAmountCents({
+        service: {
+          eventService: {
+            pricingModel: "PER_ATTENDEE",
+            baseRateCents: 500,
+          },
+        },
+        durationHours: 4,
+        expectedAttendees: 100,
+      })
+    ).toBe(50_000);
+  });
+});
+
+describe("isBulkHostOfferEligible", () => {
+  it("rejects participation-fee services", () => {
+    expect(isBulkHostOfferEligible(50_000, true)).toBe(false);
+  });
+
+  it("requires a positive amount", () => {
+    expect(isBulkHostOfferEligible(0, false)).toBe(false);
+    expect(isBulkHostOfferEligible(25_000, false)).toBe(true);
+  });
+});