@bash-app/bash-common 30.183.0 → 30.193.0

package/src/stripeListingSubscriptionMessages.ts

@@ -0,0 +1,18 @@
+/**
+ * User-facing copy for listing-subscription (Connect billing customer) payment flows.
+ * Kept in bash-common so api and bash-app stay aligned without casts.
+ */
+
+const STRIPE_ALREADY_ATTACHED_SUBSTR = /already been attached to a customer/i;
+
+export const LISTING_SUBSCRIPTION_PAYMENT_ALREADY_LINKING_USER_MESSAGE =
+  "Your card is still linking to billing. Wait a few seconds and tap Confirm again.";
+
+export function userFacingMessageForListingSubscriptionStripeError(
+  raw: string
+): string {
+  if (STRIPE_ALREADY_ATTACHED_SUBSTR.test(raw)) {
+    return LISTING_SUBSCRIPTION_PAYMENT_ALREADY_LINKING_USER_MESSAGE;
+  }
+  return raw;
+}

package/src/utils/addressUtils.ts

@@ -14,17 +14,98 @@ export function addressValuesToDatabaseAddressString(addressValues: IAddress): s
   return [place, street, city, state, zipCode, country].join(ADDRESS_DELIM);
 }
 
+/**
+ * Older Where step saved locations with a " • " join and dropped empty segments,
+ * so the value no longer contained `|` and the full address was mis-parsed as `place`.
+ */
+function parseLegacyBulletDelimitedAddress(trimmed: string): IAddress | null {
+  if (!trimmed.includes(' • ')) {
+    return null;
+  }
+  const parts = trimmed.split(' • ').map((p) => p.trim()).filter((p) => p.length > 0);
+  const zipLike = (s: string) => /^\d{5}(-\d{4})?$/.test(s);
+
+  if (parts.length === 6) {
+    return {
+      place: parts[0] ?? '',
+      street: parts[1] ?? '',
+      city: parts[2] ?? '',
+      state: parts[3] ?? '',
+      zipCode: parts[4] ?? '',
+      country: parts[5] ?? 'USA',
+    };
+  }
+
+  const zip3 = parts[3] ?? '';
+  const zip4 = parts[4] ?? '';
+  // Typical corruption: empty place dropped → "street • city • state • zip • USA"
+  if (
+    parts.length === 5 &&
+    zipLike(zip3) &&
+    /^(USA|United States)$/i.test(zip4)
+  ) {
+    return {
+      place: '',
+      street: parts[0] ?? '',
+      city: parts[1] ?? '',
+      state: parts[2] ?? '',
+      zipCode: parts[3] ?? '',
+      country: 'USA',
+    };
+  }
+
+  // "place • street • city • state • zip" (no country segment)
+  if (parts.length === 5 && zipLike(zip4)) {
+    return {
+      place: parts[0] ?? '',
+      street: parts[1] ?? '',
+      city: parts[2] ?? '',
+      state: parts[3] ?? '',
+      zipCode: parts[4] ?? '',
+      country: 'USA',
+    };
+  }
+
+  if (parts.length === 4 && zipLike(parts[3] ?? '')) {
+    return {
+      place: '',
+      street: parts[0] ?? '',
+      city: parts[1] ?? '',
+      state: parts[2] ?? '',
+      zipCode: parts[3] ?? '',
+      country: 'USA',
+    };
+  }
+
+  return null;
+}
+
 export function databaseAddressStringToAddressValues(addressString: string | undefined | null): IAddress {
   if (addressString) {
-    const addressArray = addressString.split(ADDRESS_DELIM);
-    return {
-      place: addressArray[0],
-      street: addressArray[1],
-      city: addressArray[2],
-      state: addressArray[3],
-      zipCode: addressArray[4],
-      country: 'USA'
+    const trimmed = addressString.trim();
+    if (trimmed.includes(ADDRESS_DELIM)) {
+      const addressArray = trimmed.split(ADDRESS_DELIM);
+      return {
+        place: addressArray[0] ?? '',
+        street: addressArray[1] ?? '',
+        city: addressArray[2] ?? '',
+        state: addressArray[3] ?? '',
+        zipCode: addressArray[4] ?? '',
+        country: addressArray[5]?.trim() || 'USA',
+      };
+    }
+    const legacyBullet = parseLegacyBulletDelimitedAddress(trimmed);
+    if (legacyBullet) {
+      return legacyBullet;
     }
+    return {
+      place: trimmed,
+      street: '',
+      city: '',
+      state: '',
+      zipCode: '',
+      country: '',
+    };
   }
   return { place: '', street: '', city: '', state: '', zipCode: '', country: '' };
 }
@@ -46,54 +127,45 @@ export function formatLocalityForCardDisplay(
 }
 
 export function databaseAddressStringToOneLineString(addressString: string | undefined | null): string {
-  if (addressString) {
-    // Special handling for place-only addresses
-    if (!addressString.includes(ADDRESS_DELIM)) {
-      return addressString.trim();
-    }
-    
-    const address = databaseAddressStringToAddressValues(addressString);
-    
-    // If only place exists, just return it
-    if (address.place && 
-        (!address.street || address.street === 'undefined') && 
-        (!address.city || address.city === 'undefined') && 
-        (!address.state || address.state === 'undefined')) {
-      return address.place.trim();
-    }
-    
-    let addressArr = address.place ? [address.place] : [];
-    
-    // Add non-empty and non-undefined parts
-    if (address.street && address.street !== 'undefined') addressArr.push(address.street);
-    if (address.city && address.city !== 'undefined') addressArr.push(address.city);
-    if (address.state && address.state !== 'undefined') addressArr.push(address.state);
-    
-    const addressStr = addressArr.filter(str => !!str && str !== 'undefined').join(', ');
-    
-    // Only add zip code if it exists and isn't 'undefined'
-    return address.zipCode && address.zipCode !== 'undefined' 
-      ? `${addressStr} ${address.zipCode}`
-      : addressStr;
+  if (!addressString) {
+    return '';
+  }
+  const address = databaseAddressStringToAddressValues(addressString);
+
+  // If only place exists, just return it (includes place-only strings with no delimiters)
+  if (
+    address.place &&
+    (!address.street || address.street === 'undefined') &&
+    (!address.city || address.city === 'undefined') &&
+    (!address.state || address.state === 'undefined')
+  ) {
+    return address.place.trim();
   }
-  return '';
+
+  let addressArr = address.place ? [address.place] : [];
+
+  if (address.street && address.street !== 'undefined') addressArr.push(address.street);
+  if (address.city && address.city !== 'undefined') addressArr.push(address.city);
+  if (address.state && address.state !== 'undefined') addressArr.push(address.state);
+
+  const addressStr = addressArr.filter((str) => !!str && str !== 'undefined').join(', ');
+
+  return address.zipCode && address.zipCode !== 'undefined'
+    ? `${addressStr} ${address.zipCode}`
+    : addressStr;
 }
 
 export function databaseAddressStringToDisplayString(addressString: string | undefined | null): string {
-  if (addressString) {
-    // Special handling for place-only addresses (no delimiters)
-    if (!addressString.includes(ADDRESS_DELIM)) {
-      return addressString.trim();
-    }
-    
-    const oneLineString = databaseAddressStringToOneLineString(addressString);
-    const formatted = oneLineString.replace(/([A-Z])(?=[A-Z][a-z])/g, "$1 ") // Add space between a single uppercase letter and a capitalized word
-                 .replace(/(\d)(?=[A-Z])/g, "$1 ") // Add space between numbers and letters
-                 .replace(/,/g, ", ") // Add space after commas
-                 .replace(/undefined/g, ""); // Remove any "undefined" strings
-    return formatted;
+  if (!addressString) {
+    return '';
   }
-  return '';
+  const oneLineString = databaseAddressStringToOneLineString(addressString);
+  const formatted = oneLineString
+    .replace(/([A-Z])(?=[A-Z][a-z])/g, '$1 ') // Add space between a single uppercase letter and a capitalized word
+    .replace(/(\d)(?=[A-Z])/g, '$1 ') // Add space between numbers and letters
+    .replace(/,/g, ', ') // Add space after commas
+    .replace(/undefined/g, ''); // Remove any "undefined" strings
+  return formatted;
 }
 
 export function addressToDisplayString(address: IAddress): string {
@@ -104,32 +176,76 @@ export function addressToDisplayString(address: IAddress): string {
 }
 
 
+/** Prefer a precise street-level result; `results[0]` is often a coarse area (wrong street line). */
+function pickBestGeocodeResult(
+  results: Array<{
+    types?: string[];
+    geometry?: { location_type?: string };
+    address_components?: GoogleAddressComponent[];
+    formatted_address?: string;
+  }>
+) {
+  if (!results?.length) return undefined;
+  const streetAddress = results.find((r) => r.types?.includes("street_address"));
+  if (streetAddress) return streetAddress;
+  const premise = results.find((r) => r.types?.includes("premise"));
+  if (premise) return premise;
+  const rooftop = results.find((r) => r.geometry?.location_type === "ROOFTOP");
+  if (rooftop) return rooftop;
+  const interpolated = results.find(
+    (r) => r.geometry?.location_type === "RANGE_INTERPOLATED"
+  );
+  if (interpolated) return interpolated;
+  return results[0];
+}
+
 export async function getAddressFromCoordinates( lat: number, lng: number ): Promise<IAddress> {
   const apiUrl = `https://maps.googleapis.com/maps/api/geocode/json?latlng=${lat},${lng}&key=${googleMapsApiKey}&loading=async`;
   try {
     const response = await fetch(apiUrl);
     const data = await response.json();
     if (data.results.length > 0) {
-      const addressComponents = data.results[0].address_components;
+      const firstResult = pickBestGeocodeResult(data.results);
+      if (!firstResult?.address_components) {
+        throw new Error("No address found");
+      }
+      const addressComponents = firstResult.address_components;
 
-      let street = "";
+      let streetNumber = "";
+      let route = "";
       let city = "";
       let state = "";
       let zipCode = "";
 
       addressComponents.forEach((component: GoogleAddressComponent) => {
-        if (component.types.includes("route")) {
-          street = component.long_name;
-        } else if (component.types.includes("locality")) {
+        const types = component.types;
+        if (types.includes("street_number")) {
+          streetNumber = component.long_name;
+        }
+        if (types.includes("route")) {
+          route = component.long_name;
+        } else if (types.includes("locality")) {
           city = component.long_name;
-        } else if (component.types.includes("administrative_area_level_1")) {
+        } else if (types.includes("administrative_area_level_1")) {
           state = component.short_name;
-        } else if (component.types.includes("postal_code")) {
+        } else if (types.includes("postal_code")) {
           zipCode = component.long_name;
         }
       });
 
-      return { place: '',  street, city, state, zipCode, country: 'USA' };
+      // Match extractAddressComponents: US addresses split street across street_number + route.
+      let street = `${streetNumber} ${route}`.trim();
+      if (!street && firstResult.formatted_address) {
+        const firstSeg = firstResult.formatted_address.split(",")[0]?.trim() ?? "";
+        if (firstSeg && city && !firstSeg.toLowerCase().includes(city.toLowerCase())) {
+          street = firstSeg;
+        } else if (firstSeg && !city) {
+          street = firstSeg;
+        }
+      }
+
+      // Place is intentionally empty here — only filled when user picks a Place in Maps UI or types it.
+      return { place: "", street, city, state, zipCode, country: "USA" };
     } else {
       throw new Error("No address found");
     }

package/src/utils/discountEngine/__tests__/eligibilityValidator.test.ts

@@ -645,11 +645,15 @@ describe("eligibilityValidator", () => {
       const currentDate = new Date("2024-07-15T23:59:59Z");
       const expiryDate = new Date("2024-07-16T00:00:01Z");
 
-      const offer = { id: "offer-1", endDate: expiryDate } as any;
+      const offer = {
+        id: "offer-1",
+        isActive: true,
+        endDate: expiryDate,
+      } as any;
 
       const result = validateOfferEligibility(offer, "user-1", 2, currentDate, 0);
 
-      expect(result.eligible).toBe(true); // Still valid by 2 seconds
+      expect(result.eligible).toBe(true); // Still valid by 2 seconds (UTC)
     });
   });
 });

package/src/utils/mediaClientDefaults.ts

@@ -0,0 +1,6 @@
+/**
+ * Shared defaults for browser-side image compression (e.g. bash-app uploads).
+ * Env-specific values (max MB) stay in the app; dimensions/worker flags live here.
+ */
+export const CLIENT_IMAGE_COMPRESSION_MAX_WIDTH_OR_HEIGHT = 1920;
+export const CLIENT_IMAGE_COMPRESSION_USE_WEB_WORKER = true;

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

@@ -0,0 +1,29 @@
+/**
+ * Contract for Vendor / Exhibitor / Sponsor wizard “How” payment step (major 6, sub 3).
+ */
+import {
+  PARTNER_SERVICE_PROFILE_WIZARD_PAYMENT_METHOD_MAJOR_STEP,
+  PARTNER_SERVICE_PROFILE_WIZARD_PAYMENT_METHOD_SUB_STEP,
+  partnerServiceProfileWizardPaymentMethodUrl,
+} from "../serviceUtils";
+
+describe("partnerServiceProfileWizardPaymentMethodUrl", () => {
+  it("uses How step 6 and sub-step 3", () => {
+    expect(PARTNER_SERVICE_PROFILE_WIZARD_PAYMENT_METHOD_MAJOR_STEP).toBe(6);
+    expect(PARTNER_SERVICE_PROFILE_WIZARD_PAYMENT_METHOD_SUB_STEP).toBe(3);
+  });
+
+  it.each([
+    ["Vendors", "s1", "p1"],
+    ["Exhibitors", "s2", "p2"],
+    ["Sponsors", "s3", "p3"],
+  ] as const)("builds wizard URL for %s", (serviceType, serviceId, specificId) => {
+    expect(
+      partnerServiceProfileWizardPaymentMethodUrl(
+        serviceId,
+        serviceType,
+        specificId
+      )
+    ).toBe(`/wz/services/${serviceId}/${serviceType}/${specificId}/6/3`);
+  });
+});

package/src/utils/service/cancellationPolicyRefundResolver.ts

@@ -0,0 +1,112 @@
+import { ServiceCancellationPolicy } from "@prisma/client";
+import {
+  SERVICE_CANCELLATION_POLICY_DATA,
+  type ServiceCancellationRefundPolicy,
+} from "./serviceUtils.js";
+
+/**
+ * Converts a tier threshold from SERVICE_CANCELLATION_POLICY_DATA to hours so
+ * rules that mix `days` and `hours` are compared on one timeline.
+ */
+export function cancellationRuleThresholdHours(
+  rule: ServiceCancellationRefundPolicy
+): number {
+  if (rule.days !== undefined) {
+    return rule.days * 24;
+  }
+  if (rule.hours !== undefined) {
+    return rule.hours;
+  }
+  return 0;
+}
+
+export type ResolveCancellationRefundOptions = {
+  /** Event start time (UTC or local — caller must be consistent). */
+  eventStart: Date;
+  /** Defaults to `new Date()`. */
+  now?: Date;
+};
+
+/**
+ * Hours from `now` until `eventStart` (non-negative). Returns 0 if the event
+ * has started or `eventStart` is invalid.
+ */
+export function hoursUntilEventStart(
+  eventStart: Date,
+  now: Date = new Date()
+): number {
+  const ms = eventStart.getTime() - now.getTime();
+  if (ms <= 0 || Number.isNaN(ms)) {
+    return 0;
+  }
+  return ms / (1000 * 60 * 60);
+}
+
+/**
+ * Resolves refund as a fraction in [0, 1] from {@link SERVICE_CANCELLATION_POLICY_DATA}.
+ * For each rule, if time until start is at least that rule's threshold, the rule
+ * applies; when multiple apply, the highest `refundPercentage` wins (matches
+ * tiered "full → partial → none" semantics).
+ */
+export function resolveCancellationRefundFraction(
+  policy: ServiceCancellationPolicy | null | undefined,
+  options: ResolveCancellationRefundOptions
+): number {
+  if (policy == null || policy === ServiceCancellationPolicy.None) {
+    return 0;
+  }
+  const data = SERVICE_CANCELLATION_POLICY_DATA[policy];
+  if (!data?.refundPolicy?.length) {
+    return 0;
+  }
+
+  const now = options.now ?? new Date();
+  const hoursUntil = hoursUntilEventStart(options.eventStart, now);
+  if (hoursUntil <= 0) {
+    return 0;
+  }
+
+  let bestPercent = 0;
+  for (const rule of data.refundPolicy) {
+    const thresholdHours = cancellationRuleThresholdHours(rule);
+    if (hoursUntil >= thresholdHours && rule.refundPercentage > bestPercent) {
+      bestPercent = rule.refundPercentage;
+    }
+  }
+
+  return bestPercent / 100;
+}
+
+/**
+ * The winning tier rule for display (e.g. service booking UI), or null if none.
+ */
+export function getMatchingCancellationRefundRule(
+  policy: ServiceCancellationPolicy | null | undefined,
+  options: ResolveCancellationRefundOptions
+): ServiceCancellationRefundPolicy | null {
+  if (policy == null || policy === ServiceCancellationPolicy.None) {
+    return null;
+  }
+  const data = SERVICE_CANCELLATION_POLICY_DATA[policy];
+  if (!data?.refundPolicy?.length) {
+    return null;
+  }
+
+  const now = options.now ?? new Date();
+  const hoursUntil = hoursUntilEventStart(options.eventStart, now);
+  if (hoursUntil <= 0) {
+    return null;
+  }
+
+  let bestRule: ServiceCancellationRefundPolicy | null = null;
+  let bestPercent = 0;
+  for (const rule of data.refundPolicy) {
+    const thresholdHours = cancellationRuleThresholdHours(rule);
+    if (hoursUntil >= thresholdHours && rule.refundPercentage > bestPercent) {
+      bestPercent = rule.refundPercentage;
+      bestRule = rule;
+    }
+  }
+
+  return bestRule;
+}

package/src/utils/service/frontendServiceBookingUtils.ts

@@ -32,14 +32,10 @@ import {
   ServiceBookingPriceBreakdownBaseT,
   ServiceBookingAddOnBase,
 } from "./serviceBookingTypes.js";
-import { convertDollarsToCents } from "../paymentUtils.js";
-import { SERVICE_BOOKING_FEES } from "../../membershipDefinitions.js";
-
-// Use centralized service fee percentage (2.9% Stripe fee for Basic tier)
-// Note: This is ONLY the Stripe payment processing fee (2.9% + $0.30).
-// We charge 0% platform fee - this is transparent pass-through pricing.
-// See SERVICE_BOOKING_FEES in membershipDefinitions.ts for all tier-based fees.
-export const SERVICE_BOOKING_PROCESSING_FEE_PERCENT = SERVICE_BOOKING_FEES.Basic.percent;
+import {
+  calculateStripeProcessingFeeCents,
+  convertDollarsToCents,
+} from "../paymentUtils.js";
 
 export interface ServiceAddonInput extends ServiceAddon {
   chosenQuantity?: number;
@@ -293,10 +289,9 @@ export function frontendServiceGetPriceToBookFees(
   const subtotalBeforeTaxesCents = daysTotalBeforeTaxesCents + addOnsTotalCents;
 
   if (!hasCustomProcessingFee) {
-    // Calculate Stripe's processing fee: 2.9% + $0.30
+    // Same pass-through formula as bash ticket/donation checkout (STRIPE_PROCESSING_FEE).
     const processingFeeCents =
-      Math.floor(SERVICE_BOOKING_PROCESSING_FEE_PERCENT * subtotalBeforeTaxesCents) + 
-      SERVICE_BOOKING_FEES.Basic.fixedCents;
+      calculateStripeProcessingFeeCents(subtotalBeforeTaxesCents);
 
     allAdditionalFees.push({
       feeType: ServiceBookingFeeType.ProcessingFee,