@bash-app/bash-common 30.427.0 → 30.430.0

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

@@ -0,0 +1,117 @@
+import {
+  resolveTicketTierScheduleState,
+  scheduleValidationHasErrors,
+  validateTicketTierScheduleInput,
+} from "../ticketTierSchedule.js";
+
+/** Sale opens at availableAt and closes at expiresAt. Boundaries are inclusive on open, exclusive on the last millisecond before close. */
+const RELEASE = new Date("2026-12-11T01:00:00.000Z");
+const EXPIRES = new Date("2026-12-17T13:00:00.000Z");
+const INVENTORY = { availableInventory: 40 };
+
+function shift(instant: Date, ms: number): Date {
+  return new Date(instant.getTime() + ms);
+}
+
+describe("ticket release and expiry windows", () => {
+  it("keeps a release-only tier off sale until the release instant, then on sale", () => {
+    const tier = { availabilityType: "OnDate", availableAt: RELEASE };
+
+    const before = resolveTicketTierScheduleState(tier, {
+      ...INVENTORY,
+      now: shift(RELEASE, -1),
+    });
+    const atRelease = resolveTicketTierScheduleState(tier, {
+      ...INVENTORY,
+      now: RELEASE,
+    });
+    const later = resolveTicketTierScheduleState(tier, {
+      ...INVENTORY,
+      now: shift(RELEASE, 7 * 24 * 60 * 60 * 1000),
+    });
+
+    expect(before.canPurchase).toBe(false);
+    expect(before.phase).toBe("TeasePreRelease");
+    expect(atRelease.canPurchase).toBe(true);
+    expect(atRelease.phase).toBe("Live");
+    expect(later.canPurchase).toBe(true);
+    expect(later.phase).toBe("Live");
+  });
+
+  it("treats a past release as already on sale", () => {
+    const issues = validateTicketTierScheduleInput({
+      availabilityType: "OnDate",
+      availableAt: shift(RELEASE, -60_000),
+    });
+    expect(scheduleValidationHasErrors(issues)).toBe(false);
+
+    const state = resolveTicketTierScheduleState(
+      { availabilityType: "OnDate", availableAt: shift(RELEASE, -60_000) },
+      { ...INVENTORY, now: RELEASE }
+    );
+    expect(state.canPurchase).toBe(true);
+    expect(state.phase).toBe("Live");
+  });
+
+  it("keeps an expiry-only tier on sale until the expiration instant", () => {
+    const tier = { availabilityType: "Immediate", expiresAt: EXPIRES };
+
+    const before = resolveTicketTierScheduleState(tier, {
+      ...INVENTORY,
+      now: shift(EXPIRES, -1),
+    });
+    const atExpiry = resolveTicketTierScheduleState(tier, {
+      ...INVENTORY,
+      now: EXPIRES,
+    });
+
+    expect(before.canPurchase).toBe(true);
+    expect(before.phase).toBe("Live");
+    expect(atExpiry.canPurchase).toBe(false);
+    expect(atExpiry.phase).toBe("Expired");
+    expect(atExpiry.guestVisible).toBe(false);
+  });
+
+  it("sells a dated tier only inside the release-to-expiry window", () => {
+    const tier = {
+      availabilityType: "OnDate",
+      availableAt: RELEASE,
+      expiresAt: EXPIRES,
+    };
+
+    expect(
+      resolveTicketTierScheduleState(tier, {
+        ...INVENTORY,
+        now: shift(RELEASE, -1),
+      }).canPurchase
+    ).toBe(false);
+    expect(
+      resolveTicketTierScheduleState(tier, {
+        ...INVENTORY,
+        now: RELEASE,
+      }).phase
+    ).toBe("Live");
+    expect(
+      resolveTicketTierScheduleState(tier, {
+        ...INVENTORY,
+        now: shift(EXPIRES, -1),
+      }).canPurchase
+    ).toBe(true);
+    expect(
+      resolveTicketTierScheduleState(tier, {
+        ...INVENTORY,
+        now: EXPIRES,
+      }).phase
+    ).toBe("Expired");
+  });
+
+  it("rejects an expiration that is not after the release", () => {
+    const issues = validateTicketTierScheduleInput({
+      availabilityType: "OnDate",
+      availableAt: EXPIRES,
+      expiresAt: RELEASE,
+    });
+    expect(scheduleValidationHasErrors(issues)).toBe(true);
+    expect(issues.some((issue) => issue.field === "expiresAt")).toBe(true);
+  });
+});

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

@@ -115,9 +115,21 @@ describe("resolveTicketTierScheduleState", () => {
 });
 
 describe("validateTicketTierScheduleInput", () => {
-  it("requires availableAt for OnDate", () => {
-    const issues = validateTicketTierScheduleInput({ availabilityType: "OnDate" });
-    expect(scheduleValidationHasErrors(issues)).toBe(true);
+  it("treats a missing release datetime as already on sale", () => {
+    const releaseOnly = validateTicketTierScheduleInput({
+      availabilityType: "OnDate",
+      availableAt: new Date("2030-06-02T12:00:00Z"),
+    });
+    const expireOnly = validateTicketTierScheduleInput({
+      availabilityType: "Immediate",
+      expiresAt: new Date("2030-06-02T12:00:00Z"),
+    });
+    const unsetRelease = validateTicketTierScheduleInput({
+      availabilityType: "OnDate",
+    });
+    expect(scheduleValidationHasErrors(releaseOnly)).toBe(false);
+    expect(scheduleValidationHasErrors(expireOnly)).toBe(false);
+    expect(scheduleValidationHasErrors(unsetRelease)).toBe(false);
   });
 
   it("rejects expires before release", () => {

package/src/utils/feedPostSocialLinks.ts

@@ -0,0 +1,174 @@
+/**
+ * Links stored on a service-mode BashFeed post. Not written back to a profile.
+ */
+export const FEED_POST_SOCIAL_PLATFORMS = [
+  "Instagram",
+  "LinkedIn",
+  "X",
+  "Website",
+] as const;
+
+export const FEED_POST_SOCIAL_LINK_MAX = 5;
+
+export type FeedPostSocialPlatform = (typeof FEED_POST_SOCIAL_PLATFORMS)[number];
+
+export type FeedPostSocialLink = {
+  platform: FeedPostSocialPlatform;
+  url: string;
+  label?: string;
+};
+
+function isPlatform(value: string): value is FeedPostSocialPlatform {
+  return (FEED_POST_SOCIAL_PLATFORMS as readonly string[]).includes(value);
+}
+
+/** https URL, or null when the value is not a normal web link. */
+export function toFeedPostHttpsUrl(raw: string): string | null {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  if (/^(javascript|data|file|mailto|tel):/i.test(trimmed)) return null;
+
+  let candidate = trimmed;
+  if (/^http:\/\//i.test(candidate)) {
+    candidate = `https://${candidate.slice("http://".length)}`;
+  } else if (!/^https:\/\//i.test(candidate)) {
+    if (candidate.startsWith("@")) return null;
+    candidate = `https://${candidate.replace(/^\/+/, "")}`;
+  }
+
+  try {
+    const url = new URL(candidate);
+    if (url.protocol !== "https:") return null;
+    if (!url.hostname || !url.hostname.includes(".")) return null;
+    return url.toString();
+  } catch {
+    return null;
+  }
+}
+
+function handleToHttps(platform: FeedPostSocialPlatform, raw: string): string | null {
+  const trimmed = raw.trim();
+  const handle = trimmed.replace(/^@/, "");
+  if (!handle || /\s/.test(handle)) return null;
+  if (platform === "Instagram") return toFeedPostHttpsUrl(`https://instagram.com/${handle}`);
+  if (platform === "X") return toFeedPostHttpsUrl(`https://x.com/${handle}`);
+  if (platform === "LinkedIn") return toFeedPostHttpsUrl(`https://www.linkedin.com/in/${handle}`);
+  return null;
+}
+
+export function parseFeedPostSocialLinks(
+  input: unknown
+): { links: FeedPostSocialLink[] } | { error: string } {
+  if (input == null) return { links: [] };
+  if (!Array.isArray(input)) {
+    return { error: "Social links must be a list." };
+  }
+  if (input.length > FEED_POST_SOCIAL_LINK_MAX) {
+    return { error: `Add up to ${FEED_POST_SOCIAL_LINK_MAX} links.` };
+  }
+
+  const links: FeedPostSocialLink[] = [];
+  for (const row of input) {
+    if (!row || typeof row !== "object") {
+      return { error: "Each social link needs a platform and a URL." };
+    }
+    const record = row as { platform?: unknown; url?: unknown; label?: unknown };
+    const platform = typeof record.platform === "string" ? record.platform.trim() : "";
+    const urlRaw = typeof record.url === "string" ? record.url : "";
+    if (!isPlatform(platform)) {
+      return { error: "Use Instagram, LinkedIn, X, or a website." };
+    }
+    const url =
+      toFeedPostHttpsUrl(urlRaw) ??
+      (urlRaw.trim().startsWith("@") ? handleToHttps(platform, urlRaw) : null);
+    if (!url) {
+      return { error: "Links need a normal https address." };
+    }
+    const label =
+      typeof record.label === "string" && record.label.trim()
+        ? record.label.trim().slice(0, 40)
+        : undefined;
+    links.push(label ? { platform, url, label } : { platform, url });
+  }
+  return { links };
+}
+
+function urlKey(url: string): string {
+  try {
+    const parsed = new URL(url);
+    const host = parsed.hostname.replace(/^www\./, "").toLowerCase();
+    const path = parsed.pathname.replace(/\/$/, "").toLowerCase();
+    return `${host}${path}`;
+  } catch {
+    return url.trim().toLowerCase();
+  }
+}
+
+/** Drop links that match the poster's own profile URLs. */
+export function withoutPosterSocialLinks(
+  links: FeedPostSocialLink[],
+  posterUrls: Array<string | null | undefined>
+): FeedPostSocialLink[] {
+  const blocked = new Set<string>();
+  for (const raw of posterUrls) {
+    if (!raw?.trim()) continue;
+    const https = toFeedPostHttpsUrl(raw);
+    if (https) blocked.add(urlKey(https));
+  }
+  if (blocked.size === 0) return links;
+  return links.filter((link) => !blocked.has(urlKey(link.url)));
+}
+
+function pushUnique(
+  links: FeedPostSocialLink[],
+  platform: FeedPostSocialPlatform,
+  raw: string
+): void {
+  if (links.length >= FEED_POST_SOCIAL_LINK_MAX) return;
+  const url =
+    toFeedPostHttpsUrl(raw) ??
+    (raw.trim().startsWith("@") ? handleToHttps(platform, raw) : null);
+  if (!url) return;
+  if (links.some((link) => link.platform === platform && urlKey(link.url) === urlKey(url))) {
+    return;
+  }
+  links.push({ platform, url });
+}
+
+/**
+ * Prefill from an organization's stored social JSON and website.
+ * Accepts `{ instagram, linkedin, x, twitter, website }` or an array of `{ platform, url }`.
+ */
+export function providerLinksFromOrganization(
+  socialLinks: unknown,
+  websiteUrl: string | null | undefined
+): FeedPostSocialLink[] {
+  const links: FeedPostSocialLink[] = [];
+  if (websiteUrl?.trim()) {
+    pushUnique(links, "Website", websiteUrl);
+  }
+  if (!socialLinks) return links;
+
+  if (Array.isArray(socialLinks)) {
+    const parsed = parseFeedPostSocialLinks(socialLinks);
+    if ("links" in parsed) {
+      for (const link of parsed.links) pushUnique(links, link.platform, link.url);
+    }
+    return links;
+  }
+
+  if (typeof socialLinks !== "object") return links;
+  const record = socialLinks as Record<string, unknown>;
+  const pairs: Array<[FeedPostSocialPlatform, unknown]> = [
+    ["Instagram", record.instagram ?? record.Instagram],
+    ["LinkedIn", record.linkedin ?? record.LinkedIn],
+    ["X", record.x ?? record.X ?? record.twitter ?? record.Twitter],
+    ["Website", record.website ?? record.Website ?? record.url],
+  ];
+  for (const [platform, value] of pairs) {
+    if (typeof value === "string" && value.trim()) {
+      pushUnique(links, platform, value);
+    }
+  }
+  return links;
+}

package/src/utils/paymentUtils.ts

@@ -96,7 +96,7 @@ export function calculateTotalPriceWithoutTax(
 ): number {
   let total = 0;
   ticketTiers.forEach((tier: TicketTier) => {
-    // Only calculate USD prices - BashPoints tickets should have price=0
+    // USD and mixed tiers charge the dollar price. Points-only tiers do not.
     if (tier.pricingType !== "BASHPOINTS") {
       const ticketListNumAndDate = ticketList.get(tier.id);
       ticketListNumAndDate?.forEach((numAndDate: NumberOfTicketsForDate) => {
@@ -120,8 +120,10 @@ export function calculateTotalBashPoints(
 ): number {
   let total = 0;
   ticketTiers.forEach((tier: TicketTier) => {
-    // Only calculate BashPoints prices
-    if (tier.pricingType === "BASHPOINTS" && tier.priceBashPoints) {
+    if (
+      (tier.pricingType === "BASHPOINTS" || tier.pricingType === "MIXED") &&
+      tier.priceBashPoints
+    ) {
       const ticketListNumAndDate = ticketList.get(tier.id);
       ticketListNumAndDate?.forEach((numAndDate: NumberOfTicketsForDate) => {
         total += tier.priceBashPoints! * (numAndDate.numberOfTickets ?? 0);
@@ -131,6 +133,22 @@ export function calculateTotalBashPoints(
   return total;
 }
 
+/** BashPoints due on tiers that also charge a card (pricingType MIXED). */
+export function calculateMixedPricingBashPoints(
+  ticketTiers: TicketTier[],
+  ticketList: Map<string, NumberOfTicketsForDate[]>
+): number {
+  let total = 0;
+  ticketTiers.forEach((tier: TicketTier) => {
+    if (tier.pricingType !== "MIXED" || !tier.priceBashPoints) return;
+    const ticketListNumAndDate = ticketList.get(tier.id);
+    ticketListNumAndDate?.forEach((numAndDate: NumberOfTicketsForDate) => {
+      total += tier.priceBashPoints! * (numAndDate.numberOfTickets ?? 0);
+    });
+  });
+  return total;
+}
+
 export function convertCentsToDollars(
   price: number | undefined | null
 ): number {

package/src/utils/ticketTierSchedule.ts

@@ -325,19 +325,12 @@ export function validateTicketTierScheduleInput(
   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",
-    });
-  }
-
+  // No release datetime means the tier is already on sale. Expiration can
+  // stand alone, and a release date does not require an expiration.
   if (availableAt && expiresAt && expiresAt <= availableAt) {
     issues.push({
       field: "expiresAt",