@bash-app/bash-common 30.385.0 → 30.386.0

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

@@ -1,9 +1,14 @@
 import {
   applyAvailabilityPreset,
+  blockedRangesFromSpecialRates,
   computeEarliestOpenDate,
+  countServicesAvailableOnDate,
   detectAvailabilityPreset,
+  filterServicesAvailableOnDate,
   formatAvailabilityPresetLabel,
+  isServiceAvailableOnDate,
   parseAvailableHours,
+  type ServiceDayAvailabilityInput,
 } from "../serviceAvailabilityDisplay.js";
 
 describe("applyAvailabilityPreset", () => {
@@ -150,3 +155,71 @@ describe("computeEarliestOpenDate", () => {
     expect(result).toBeNull();
   });
 });
+
+describe("isServiceAvailableOnDate", () => {
+  const friday = new Date(2026, 8, 11); // Friday Sep 11 2026
+  const saturday = new Date(2026, 8, 12);
+
+  it("treats a listing with no hours or blocks as available", () => {
+    expect(isServiceAvailableOnDate({}, friday)).toBe(true);
+  });
+
+  it("closes weekdays when the service only works weekends", () => {
+    const service = {
+      availableHours: applyAvailabilityPreset("weekends"),
+    };
+    expect(isServiceAvailableOnDate(service, friday)).toBe(false);
+    expect(isServiceAvailableOnDate(service, saturday)).toBe(true);
+  });
+
+  it("treats owner-blocked special rates as unavailable", () => {
+    const service = {
+      serviceRatesAssociation: {
+        serviceSpecialRates: [
+          {
+            isAvailable: false,
+            startDate: friday,
+            endDate: friday,
+          },
+        ],
+      },
+    };
+    expect(isServiceAvailableOnDate(service, friday)).toBe(false);
+    expect(isServiceAvailableOnDate(service, saturday)).toBe(true);
+  });
+
+  it("treats a confirmed booking window as occupying the day", () => {
+    const service = {
+      bookedRanges: [{ start: friday, end: friday }],
+    };
+    expect(isServiceAvailableOnDate(service, friday)).toBe(false);
+    expect(isServiceAvailableOnDate(service, saturday)).toBe(true);
+  });
+
+  it("counts and filters a mixed set of listings", () => {
+    type ListedService = ServiceDayAvailabilityInput & { id: string };
+    const open: ListedService = { id: "open" };
+    const booked: ListedService = {
+      id: "booked",
+      bookedRanges: [{ start: friday, end: friday }],
+    };
+    const blocked: ListedService = {
+      id: "blocked",
+      serviceRatesAssociation: {
+        serviceSpecialRates: [
+          { isAvailable: false, startDate: friday, endDate: friday },
+        ],
+      },
+    };
+    const all: ListedService[] = [open, booked, blocked];
+    expect(countServicesAvailableOnDate(all, friday)).toBe(1);
+    expect(filterServicesAvailableOnDate(all, friday).map((s) => s.id)).toEqual(
+      ["open"]
+    );
+    expect(
+      blockedRangesFromSpecialRates(
+        blocked.serviceRatesAssociation?.serviceSpecialRates
+      )
+    ).toHaveLength(1);
+  });
+});

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

@@ -117,9 +117,11 @@ describe("getBashEventWizardPayoutStepPath", () => {
   test("How substep indices match host-flow order", () => {
     expect(BASH_EVENT_WIZARD_HOW_SUBSTEP.PRICE).toBe(0);
     expect(BASH_EVENT_WIZARD_HOW_SUBSTEP.APPLICATION).toBe(1);
-    expect(BASH_EVENT_WIZARD_HOW_SUBSTEP.PROMO_CODES).toBe(2);
-    expect(BASH_EVENT_WIZARD_HOW_SUBSTEP.TASKS).toBe(8);
-    expect(BASH_EVENT_WIZARD_HOW_SUBSTEP.PAYOUT).toBe(9);
+    expect(BASH_EVENT_WIZARD_HOW_SUBSTEP.PROMOTER_CHALLENGE).toBe(2);
+    expect(BASH_EVENT_WIZARD_HOW_SUBSTEP.PROMO_CODES).toBe(3);
+    expect(BASH_EVENT_WIZARD_HOW_SUBSTEP.GIVEAWAYS).toBe(7);
+    expect(BASH_EVENT_WIZARD_HOW_SUBSTEP.TASKS).toBe(9);
+    expect(BASH_EVENT_WIZARD_HOW_SUBSTEP.PAYOUT).toBe(10);
     expect(BASH_EVENT_WIZARD_HOW_SUBSTEP_PAYOUT).toBe(
       BASH_EVENT_WIZARD_HOW_SUBSTEP.PAYOUT
     );

package/src/utils/paymentUtils.ts

@@ -430,6 +430,32 @@ export function lowestGuestAllInPriceCents(
   return min;
 }
 
+/** Max share of attributed ticket subtotal a host can assign to a performer (50%). */
+export const MAX_TICKET_COMMISSION_BPS = 5000;
+
+/**
+ * Floor cents owed to a promo-code performer from the discounted ticket subtotal.
+ * Guest price is unchanged; this amount is withheld from the host via application_fee.
+ */
+export function ticketCommissionCents(
+  basisCents: number,
+  commissionBps: number | null | undefined
+): number {
+  if (basisCents <= 0) return 0;
+  const bps = Math.floor(Number(commissionBps) || 0);
+  if (bps <= 0) return 0;
+  const clamped = Math.min(MAX_TICKET_COMMISSION_BPS, bps);
+  return Math.floor((basisCents * clamped) / 10_000);
+}
+
+export function clampTicketCommissionBps(
+  commissionBps: number | null | undefined
+): number {
+  const bps = Math.floor(Number(commissionBps) || 0);
+  if (bps <= 0) return 0;
+  return Math.min(MAX_TICKET_COMMISSION_BPS, bps);
+}
+
 /**
  * Compute the Stripe Connect `application_fee_amount` for a ticket-style charge,
  * along with its constituent parts.
@@ -441,8 +467,10 @@ export function lowestGuestAllInPriceCents(
  *   - `bashPlatformTotalCents` and `guestPlatformLineCents` are both zero
  *   - `totalChargedCents` collapses to the discounted subtotal (no guest-line fee added)
  *   - `applicationFeeAmountCents` equals `stripeProcessingCents`
+ *     plus optional `performerCommissionCents`
  *
- * Default (`false`) preserves existing math bit-exact for every current caller.
+ * Default (`false`) preserves existing math bit-exact for every current caller
+ * when `performerCommissionCents` is omitted or 0.
  */
 export function computeTicketApplicationFeeAmountCents(args: {
   discountedSubtotalCents: number;
@@ -456,6 +484,11 @@ export function computeTicketApplicationFeeAmountCents(args: {
    * NEVER from `BashEvent.nonProfit`, which is user-entered.
    */
   isVerifiedNonprofitHost?: boolean;
+  /**
+   * Performer / street-team cut withheld from the host (not added to the guest).
+   * Must be less than remaining charge after Stripe + Bash platform fees.
+   */
+  performerCommissionCents?: number;
 }): {
   totalChargedCents: number;
   /** Stripe's 2.9% + $0.30 pass-through; unchanged by the nonprofit waiver. */
@@ -467,15 +500,27 @@ export function computeTicketApplicationFeeAmountCents(args: {
   guestPlatformLineCents: number;
   /** Guest-visible Stripe processing line (0 when host absorbs). */
   guestProcessingLineCents: number;
+  /** Host-withheld performer cut included in application_fee. */
+  performerCommissionCents: number;
 } {
   const breakdown = computeGuestTicketCheckoutBreakdown(args);
+  const performerCommissionCents = Math.max(
+    0,
+    Math.floor(args.performerCommissionCents ?? 0)
+  );
+  const maxWithhold = Math.max(
+    0,
+    breakdown.totalDueCents - breakdown.applicationFeeAmountCents - 1
+  );
+  const withheld = Math.min(performerCommissionCents, maxWithhold);
   return {
     totalChargedCents: breakdown.totalDueCents,
     stripeProcessingCents: breakdown.stripeProcessingCents,
     bashPlatformTotalCents: breakdown.bashPlatformTotalCents,
-    applicationFeeAmountCents: breakdown.applicationFeeAmountCents,
+    applicationFeeAmountCents: breakdown.applicationFeeAmountCents + withheld,
     guestPlatformLineCents: breakdown.guestPlatformLineCents,
     guestProcessingLineCents: breakdown.guestProcessingLineCents,
+    performerCommissionCents: withheld,
   };
 }
 

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 {