@tribe-nest/forge 3.29.0 → 3.31.0

package/src/data/queries/useBroadcasts.ts

@@ -29,3 +29,154 @@ export function useValidateBroadcastPass() {
     },
   });
 }
+
+/**
+ * ONE broadcast, by id.
+ *
+ * Not the same thing as picking the id out of `useLiveBroadcasts()`: the list is
+ * what is on now, and a broadcast that has ENDED still has to render its own
+ * page (the "broadcast ended, keep this tab open" screen). Reading the detail
+ * endpoint is what makes that page survive the end of the stream.
+ */
+export function useLiveBroadcast(broadcastId?: string) {
+  const { client, profileId } = useForge();
+
+  return useQuery<ILiveBroadcast>({
+    queryKey: ["live-broadcast", profileId, broadcastId],
+    queryFn: async () => {
+      const res = await client.get(`/public/broadcasts/${broadcastId}`, {
+        params: { profileId },
+      });
+      return res.data;
+    },
+    enabled: !!profileId && !!client && !!broadcastId,
+  });
+}
+
+/**
+ * The same broadcast, re-read on an interval, purely to notice that it ended.
+ *
+ * A separate query from `useLiveBroadcast` on purpose. The page keeps rendering
+ * the broadcast it opened with, and only the END is allowed to come from the
+ * poll, so a mid-stream edit to the title or the thumbnail cannot swap the
+ * player out from under someone who is watching.
+ */
+export function useLiveBroadcastPoll(broadcastId?: string, intervalMs = 5000) {
+  const { client, profileId } = useForge();
+
+  return useQuery<ILiveBroadcast>({
+    queryKey: ["live-broadcast-poll", profileId, broadcastId],
+    queryFn: async () => {
+      const res = await client.get(`/public/broadcasts/${broadcastId}`, {
+        params: { profileId },
+      });
+      return res.data;
+    },
+    enabled: !!profileId && !!client && !!broadcastId,
+    refetchInterval: intervalMs,
+  });
+}
+
+/** How many people are watching right now. Polled while the broadcast is on. */
+export function useBroadcastAudience(broadcastId?: string, enabled = true, intervalMs = 3000) {
+  const { client, profileId } = useForge();
+
+  return useQuery<{ count: number }>({
+    queryKey: ["broadcast-audience", broadcastId],
+    queryFn: async () => {
+      const res = await client.get(`/public/broadcasts/${broadcastId}/audience`, {
+        params: { profileId },
+      });
+      return res.data;
+    },
+    enabled: !!profileId && !!client && !!broadcastId && enabled,
+    refetchInterval: intervalMs,
+  });
+}
+
+/** Which chat surface a broadcast comment arrived from. */
+export const BroadcastChannelProvider = {
+  Youtube: "youtube",
+  Twitch: "twitch",
+  Website: "website",
+  CustomRTMP: "custom_rtmp",
+} as const;
+
+export type BroadcastChannelProviderValue =
+  (typeof BroadcastChannelProvider)[keyof typeof BroadcastChannelProvider];
+
+/** One message in a broadcast's live chat. */
+export type BroadcastComment = {
+  id: string;
+  name: string;
+  content: string;
+  publishedAt: string;
+  channelProvider: BroadcastChannelProviderValue;
+};
+
+/** The chat backlog a viewer sees when they join. Realtime arrives over the socket. */
+export function useBroadcastComments(broadcastId?: string) {
+  const { client, profileId } = useForge();
+
+  return useQuery<BroadcastComment[]>({
+    queryKey: ["broadcast-comments", profileId, broadcastId],
+    queryFn: async () => {
+      const res = await client.get(`/public/broadcasts/${broadcastId}/comments`, {
+        params: { profileId },
+      });
+      return res.data;
+    },
+    enabled: !!profileId && !!client && !!broadcastId,
+  });
+}
+
+/** The offer/answer exchange that subscribes a viewer to a WebRTC broadcast. */
+export type BroadcastSubscribeAnswer = {
+  requiresImmediateRenegotiation: boolean;
+  sessionId: string;
+  tracks: { trackName: string; mid: string; trackSid: string }[];
+  sessionDescription: { sdp: string; type: string };
+};
+
+/**
+ * The imperative half of watching a broadcast: the calls that are made in
+ * response to something happening (a pass validated, a heartbeat, a viewer
+ * closing the tab), not on a render.
+ *
+ * They live here rather than inline in a component so both rendering stacks make
+ * the SAME call to the same address. A session that is pinged on one stack and
+ * not the other reports a different audience count for the same room.
+ */
+export function useBroadcastSessionApi() {
+  const { client } = useForge();
+
+  return {
+    /** Re-open a session held in storage from an earlier visit. */
+    validateSession: async (broadcastId: string, sessionId: string): Promise<IBroadcastPass> => {
+      const res = await client.post(`/public/broadcasts/${broadcastId}/validate-session`, { sessionId });
+      return res.data;
+    },
+    /** Heartbeat. Silence is what marks a viewer as gone. */
+    sessionPing: async (broadcastId: string, sessionId: string): Promise<void> => {
+      await client.post(`/public/broadcasts/${broadcastId}/session-ping`, { sessionId });
+    },
+    /** Leave deliberately, so the count drops now rather than on a timeout. */
+    leave: async (broadcastId: string, sessionId?: string): Promise<void> => {
+      await client.post(`/public/broadcasts/${broadcastId}/leave`, { sessionId });
+    },
+    /** Subscribe to the WebRTC tracks of a realtime broadcast. */
+    subscribe: async (payload: {
+      sdp?: string;
+      type?: string;
+      trackIds?: string[];
+      sessionId?: string;
+    }): Promise<BroadcastSubscribeAnswer> => {
+      const res = await client.post(`/public/broadcasts/subscribe`, payload);
+      return res.data;
+    },
+    /** Pin the viewer to one simulcast layer, or back to auto. */
+    switchQuality: async (payload: { track: Record<string, unknown>; sessionId?: string }): Promise<void> => {
+      await client.post(`/public/broadcasts/switch-quality`, payload);
+    },
+  };
+}

package/src/data/queries/useMyBookings.ts

@@ -148,7 +148,15 @@ export type MyBooking = {
  */
 export type BookingLocation =
   | { type: "in_person"; address: string }
-  | { type: "online"; url: string };
+  | { type: "online"; url: string }
+  /**
+   * A call on the platform's own media network. No payload, and there never
+   * will be one: entry is a ticket minted per attempt and valid for minutes, so
+   * a URL here would be a forwardable key to somebody else's session. Draw the
+   * Join control from `bookingCallWindow` in `@tribe-nest/forge/media` and let
+   * `<BookingCallProvider>` fetch the ticket.
+   */
+  | { type: "video" };
 
 export type CancelBookingResult = {
   bookingId: string;

package/src/i18n/de.json

@@ -4,14 +4,22 @@
   "forge.account_dashboard.booking_cancel_error": "Wir konnten diese Session nicht stornieren. Bitte versuche es erneut.",
   "forge.account_dashboard.booking_duration": "{minutes} Minuten",
   "forge.account_dashboard.booking_join_label": "Teilnehmen:",
+  "forge.account_dashboard.booking_video_call": "Videoanruf auf dieser Website",
   "forge.account_dashboard.booking_where_label": "Wo:",
   "forge.account_dashboard.cancel": "Abbrechen",
+  "forge.account_dashboard.cancel_confirm_confirm": "Mitgliedschaft kündigen",
+  "forge.account_dashboard.cancel_confirm_free": "Ihre Vorteile enden sofort.",
+  "forge.account_dashboard.cancel_confirm_keep": "Mitgliedschaft behalten",
+  "forge.account_dashboard.cancel_confirm_paid": "Sie wird nicht verlängert, und Ihre Vorteile bleiben bis zum Ende des bezahlten Zeitraums bestehen.",
+  "forge.account_dashboard.cancel_confirm_paid_until": "Sie wird nicht verlängert, und Ihre Vorteile bleiben bis zum {{date}} bestehen.",
+  "forge.account_dashboard.cancel_confirm_title": "Mitgliedschaft kündigen?",
   "forge.account_dashboard.cancel_deletion": "Löschung abbrechen",
   "forge.account_dashboard.cancel_session": "Session stornieren",
   "forge.account_dashboard.cancel_ticket": "Ticket stornieren",
   "forge.account_dashboard.cancelled": "Storniert",
   "forge.account_dashboard.cancelling": "Wird storniert…",
   "forge.account_dashboard.close": "Schließen",
+  "forge.account_dashboard.community_spaces": "Community-Bereiche",
   "forge.account_dashboard.confirm_password": "Neues Passwort bestätigen",
   "forge.account_dashboard.current_password": "Aktuelles Passwort",
   "forge.account_dashboard.data_export_description": "Exportiere eine Kopie deiner persönlichen Daten.",
@@ -139,6 +147,28 @@
   "forge.blog_post.not_found": "Beitrag nicht gefunden.",
   "forge.blog_post.pause": "Pause",
   "forge.blog_post.play": "Abspielen",
+  "forge.broadcast_pass_validation.input_placeholder": "Gib deine Ticket-ID ein (TN-XXXXXXX)",
+  "forge.broadcast_pass_validation.join": "Übertragung beitreten",
+  "forge.broadcast_pass_validation.or": "ODER",
+  "forge.broadcast_pass_validation.prompt": "Gib deine Ticket-ID ein, um der Übertragung beizutreten (TN-XXXXXXX)",
+  "forge.broadcast_pass_validation.validating": "Wird geprüft…",
+  "forge.broadcast_player.anonymous": "Anonym",
+  "forge.broadcast_player.chat": "Chat",
+  "forge.broadcast_player.fullscreen": "Vollbild",
+  "forge.broadcast_player.message_label": "Nachricht",
+  "forge.broadcast_player.pinned": "Angepinnt",
+  "forge.broadcast_player.quality": "Qualität",
+  "forge.broadcast_player.quality_auto": "Automatisch",
+  "forge.broadcast_player.quality_high": "Hoch",
+  "forge.broadcast_player.quality_low": "Niedrig",
+  "forge.broadcast_player.quality_medium": "Mittel",
+  "forge.broadcast_player.send": "Senden",
+  "forge.broadcast_player.started": "Vor {duration} gestartet",
+  "forge.broadcast_player.watching_now": "{count} schauen gerade zu",
+  "forge.broadcast_ticket_purchase.buy_tickets": "Tickets kaufen",
+  "forge.broadcast_ticket_purchase.from_price": "Ab {price}",
+  "forge.broadcast_watch.leave": "Übertragung verlassen",
+  "forge.broadcast_watch.load_error": "Übertragung konnte nicht geladen werden",
   "forge.bundle_confirmation.continue_shopping": "Weiter einkaufen",
   "forge.bundle_confirmation.eyebrow": "Bestellung bestätigt",
   "forge.bundle_confirmation.failed_body": "Es wurde nichts abgebucht und dein Warenkorb ist noch da. Du kannst es erneut versuchen.",
@@ -519,6 +549,12 @@
   "forge.email_list_form.submitting": "Wird eingetragen…",
   "forge.email_list_form.success": "Danke für deine Anmeldung!",
   "forge.email_list_form.title": "Meinem E-Mail-Verteiler beitreten",
+  "forge.ended_broadcast.banner": "Übertragung beendet",
+  "forge.ended_broadcast.close_instruction": "Schließe die Übertragungsseite mit dem \"X\" oben links, dann landest du auf der Seite mit den Live-Events des Hosts.",
+  "forge.ended_broadcast.notice_title": "Wichtige Information",
+  "forge.ended_broadcast.refresh_instruction": "Du kannst diese Seite immer wieder neu laden, bis die Übertragung wieder läuft. Tritt ihr dann bei und du kannst das Event weiter ansehen. Du bekommst außerdem eine E-Mail, sobald die Übertragung wieder läuft.",
+  "forge.ended_broadcast.why_body": "Wenn das mitten im Event passiert ist, lag es sehr wahrscheinlich an einer instabilen Internetverbindung beim Host.",
+  "forge.ended_broadcast.why_label": "Warum wurde die Übertragung beendet?",
   "forge.event_confirmation.body_incomplete": "Deine Bestellung ist {status}. Falls dir etwas berechnet wurde, melde dich beim Support.",
   "forge.event_confirmation.body_paid": "Wir haben deine Tickets an {email} geschickt.",
   "forge.event_confirmation.explore": "Mehr Events ansehen",
@@ -708,6 +744,12 @@
   "forge.lead_magnet.invalid_link": "Ungültiger Link",
   "forge.lead_magnet.preparing": "Wird vorbereitet…",
   "forge.lead_magnet.thank_you": "Danke für deine Anmeldung!",
+  "forge.live_broadcast_list.empty_body": "Zurzeit sind keine Live-Übertragungen verfügbar.",
+  "forge.live_broadcast_list.empty_title": "Keine Live-Übertragungen",
+  "forge.live_broadcast_list.error_body": "Live-Übertragungen können gerade nicht geladen werden.",
+  "forge.live_broadcast_list.error_title": "Fehler beim Laden der Übertragungen",
+  "forge.live_broadcast_list.subtitle": "Live-Streams und Events ansehen",
+  "forge.live_broadcast_list.title": "Live-Übertragungen",
   "forge.loading.loading": "Wird geladen",
   "forge.login_form.back_to_login": "Zurück zur Anmeldung",
   "forge.login_form.code_sent_to": "Wir haben einen 6-stelligen Code geschickt an",
@@ -725,17 +767,33 @@
   "forge.login_form.verify_submit": "Bestätigen & anmelden",
   "forge.login_form.verify_title": "Bestätige deine E-Mail",
   "forge.login_form.verifying": "Wird geprüft…",
+  "forge.membership_checkout.amount_below_minimum": "Bitte {minimum} oder mehr eingeben.",
+  "forge.membership_checkout.amount_not_positive": "Bitte einen Betrag größer als null eingeben.",
   "forge.membership_checkout.back": "Zurück",
   "forge.membership_checkout.billing_cycle_label": "Abrechnung",
   "forge.membership_checkout.billing_monthly": "Monatlich",
+  "forge.membership_checkout.billing_monthly_price": "Monatlich ({amount})",
+  "forge.membership_checkout.billing_monthly_pwyw": "Zahle was du willst ab {amount}/Mon.",
   "forge.membership_checkout.billing_yearly": "Jährlich",
+  "forge.membership_checkout.billing_yearly_price": "Jährlich ({amount})",
+  "forge.membership_checkout.billing_yearly_pwyw": "Zahle was du willst ab {amount}/Jahr",
+  "forge.membership_checkout.choose_title": "Mitgliedschaft wählen",
+  "forge.membership_checkout.confirm_change": "Wechsel bestätigen",
+  "forge.membership_checkout.current_plan": "Aktueller Tarif",
+  "forge.membership_checkout.empty_title": "Keine Mitgliedschaften verfügbar",
+  "forge.membership_checkout.free": "Kostenlos",
+  "forge.membership_checkout.more_benefits": "+{count} weitere",
   "forge.membership_checkout.no_tier_body": "Wähle eine Mitgliedschaft, um fortzufahren.",
+  "forge.membership_checkout.on_this_plan": "Du hast diesen Tarif",
   "forge.membership_checkout.pay": "{amount} zahlen",
   "forge.membership_checkout.payment_summary": "{tier_name} · {amount} / {cycle}",
   "forge.membership_checkout.payment_title": "Zahlung",
   "forge.membership_checkout.per_month": "pro Monat",
   "forge.membership_checkout.per_year": "pro Jahr",
+  "forge.membership_checkout.pwyw_charged_as": "Ihnen werden {{amount}} berechnet.",
   "forge.membership_checkout.pwyw_label": "Wie viel möchtest du zahlen?",
+  "forge.membership_checkout.pwyw_min": "(mindestens {amount})",
+  "forge.membership_checkout.select_tier": "Diesen Tarif wählen",
   "forge.membership_checkout.submit": "Abonnieren",
   "forge.membership_checkout.submitting": "Wird verarbeitet…",
   "forge.membership_checkout.title": "{tier_name} beitreten",
@@ -746,6 +804,7 @@
   "forge.membership_tiers.price_free": "Kostenlos",
   "forge.membership_tiers.price_monthly": "{amount}/Mon.",
   "forge.membership_tiers.price_pwyw": "Zahl, was du willst, ab {amount}/Mon.",
+  "forge.membership_tiers.price_pwyw_yearly": "Zahle was du willst ab {amount}/Jahr",
   "forge.membership_tiers.price_yearly": "{amount}/Jahr",
   "forge.membership_tiers.select": "Wählen",
   "forge.offer_button.buy_now": "Jetzt kaufen",

package/src/i18n/en.json

@@ -4,14 +4,22 @@
   "forge.account_dashboard.booking_cancel_error": "We could not cancel this session. Please try again.",
   "forge.account_dashboard.booking_duration": "{minutes} minutes",
   "forge.account_dashboard.booking_join_label": "Join:",
+  "forge.account_dashboard.booking_video_call": "Video call on this site",
   "forge.account_dashboard.booking_where_label": "Where:",
   "forge.account_dashboard.cancel": "Cancel",
+  "forge.account_dashboard.cancel_confirm_confirm": "Cancel membership",
+  "forge.account_dashboard.cancel_confirm_free": "Your benefits will stop right away.",
+  "forge.account_dashboard.cancel_confirm_keep": "Keep membership",
+  "forge.account_dashboard.cancel_confirm_paid": "It will not renew, and you keep your benefits until the end of the period you have paid for.",
+  "forge.account_dashboard.cancel_confirm_paid_until": "It will not renew, and you keep your benefits until {{date}}.",
+  "forge.account_dashboard.cancel_confirm_title": "Cancel your membership?",
   "forge.account_dashboard.cancel_deletion": "Cancel Deletion",
   "forge.account_dashboard.cancel_session": "Cancel session",
   "forge.account_dashboard.cancel_ticket": "Cancel ticket",
   "forge.account_dashboard.cancelled": "Cancelled",
   "forge.account_dashboard.cancelling": "Cancelling…",
   "forge.account_dashboard.close": "Close",
+  "forge.account_dashboard.community_spaces": "Community spaces",
   "forge.account_dashboard.confirm_password": "Confirm new password",
   "forge.account_dashboard.current_password": "Current password",
   "forge.account_dashboard.data_export_description": "Export a copy of your personal data.",
@@ -139,6 +147,28 @@
   "forge.blog_post.not_found": "Post not found.",
   "forge.blog_post.pause": "Pause",
   "forge.blog_post.play": "Play",
+  "forge.broadcast_pass_validation.input_placeholder": "Enter your ticket ID (TN-XXXXXXX)",
+  "forge.broadcast_pass_validation.join": "Join Broadcast",
+  "forge.broadcast_pass_validation.or": "OR",
+  "forge.broadcast_pass_validation.prompt": "Enter your ticket ID to join the broadcast (TN-XXXXXXX)",
+  "forge.broadcast_pass_validation.validating": "Validating…",
+  "forge.broadcast_player.anonymous": "Anonymous",
+  "forge.broadcast_player.chat": "Chat",
+  "forge.broadcast_player.fullscreen": "Fullscreen",
+  "forge.broadcast_player.message_label": "Message",
+  "forge.broadcast_player.pinned": "Pinned",
+  "forge.broadcast_player.quality": "Quality",
+  "forge.broadcast_player.quality_auto": "Auto",
+  "forge.broadcast_player.quality_high": "High",
+  "forge.broadcast_player.quality_low": "Low",
+  "forge.broadcast_player.quality_medium": "Medium",
+  "forge.broadcast_player.send": "Send",
+  "forge.broadcast_player.started": "Started {duration} ago",
+  "forge.broadcast_player.watching_now": "{count} watching now",
+  "forge.broadcast_ticket_purchase.buy_tickets": "Buy tickets",
+  "forge.broadcast_ticket_purchase.from_price": "From {price}",
+  "forge.broadcast_watch.leave": "Leave broadcast",
+  "forge.broadcast_watch.load_error": "Unable to load broadcast",
   "forge.bundle_confirmation.continue_shopping": "Continue shopping",
   "forge.bundle_confirmation.eyebrow": "Order confirmed",
   "forge.bundle_confirmation.failed_body": "Nothing was charged and your cart is still here. You can try again.",
@@ -519,6 +549,12 @@
   "forge.email_list_form.submitting": "Joining…",
   "forge.email_list_form.success": "Thanks for subscribing!",
   "forge.email_list_form.title": "Join my email list",
+  "forge.ended_broadcast.banner": "Broadcast Ended",
+  "forge.ended_broadcast.close_instruction": "Close the broadcast page with the \"X\" at the top left and you will land on the host's live events page.",
+  "forge.ended_broadcast.notice_title": "Important information",
+  "forge.ended_broadcast.refresh_instruction": "You can keep refreshing this page until the broadcast is live again. Join it and you should be able to watch the event again. You will also get an email when the broadcast is live again.",
+  "forge.ended_broadcast.why_body": "If this happened in the middle of the event, it was most likely caused by an unstable internet connection at the host's end.",
+  "forge.ended_broadcast.why_label": "Why did the broadcast end?",
   "forge.event_confirmation.body_incomplete": "Your order is {status}. If you were charged, contact support.",
   "forge.event_confirmation.body_paid": "We’ve sent your tickets to {email}.",
   "forge.event_confirmation.explore": "Browse more events",
@@ -708,6 +744,12 @@
   "forge.lead_magnet.invalid_link": "Invalid link",
   "forge.lead_magnet.preparing": "Preparing…",
   "forge.lead_magnet.thank_you": "Thank you for subscribing!",
+  "forge.live_broadcast_list.empty_body": "There are currently no live broadcasts available.",
+  "forge.live_broadcast_list.empty_title": "No Live Broadcasts",
+  "forge.live_broadcast_list.error_body": "Unable to load live broadcasts at this time.",
+  "forge.live_broadcast_list.error_title": "Error Loading Broadcasts",
+  "forge.live_broadcast_list.subtitle": "Watch live streams and events",
+  "forge.live_broadcast_list.title": "Live Broadcasts",
   "forge.loading.loading": "Loading",
   "forge.login_form.back_to_login": "Back to login",
   "forge.login_form.code_sent_to": "We sent a 6-digit code to",
@@ -725,17 +767,33 @@
   "forge.login_form.verify_submit": "Verify & Sign In",
   "forge.login_form.verify_title": "Verify your email",
   "forge.login_form.verifying": "Verifying…",
+  "forge.membership_checkout.amount_below_minimum": "Enter {minimum} or more.",
+  "forge.membership_checkout.amount_not_positive": "Enter an amount greater than zero.",
   "forge.membership_checkout.back": "Back",
   "forge.membership_checkout.billing_cycle_label": "Billing cycle",
   "forge.membership_checkout.billing_monthly": "Monthly",
+  "forge.membership_checkout.billing_monthly_price": "Monthly ({amount})",
+  "forge.membership_checkout.billing_monthly_pwyw": "Pay what you want from {amount}/mo",
   "forge.membership_checkout.billing_yearly": "Yearly",
+  "forge.membership_checkout.billing_yearly_price": "Yearly ({amount})",
+  "forge.membership_checkout.billing_yearly_pwyw": "Pay what you want from {amount}/yr",
+  "forge.membership_checkout.choose_title": "Choose your membership",
+  "forge.membership_checkout.confirm_change": "Confirm change",
+  "forge.membership_checkout.current_plan": "Current plan",
+  "forge.membership_checkout.empty_title": "No memberships available",
+  "forge.membership_checkout.free": "Free",
+  "forge.membership_checkout.more_benefits": "+{count} more",
   "forge.membership_checkout.no_tier_body": "Select a membership tier to continue.",
+  "forge.membership_checkout.on_this_plan": "You are on this plan",
   "forge.membership_checkout.pay": "Pay {amount}",
   "forge.membership_checkout.payment_summary": "{tier_name} · {amount} / {cycle}",
   "forge.membership_checkout.payment_title": "Payment",
   "forge.membership_checkout.per_month": "per month",
   "forge.membership_checkout.per_year": "per year",
+  "forge.membership_checkout.pwyw_charged_as": "You will be charged {{amount}}.",
   "forge.membership_checkout.pwyw_label": "How much would you like to pay?",
+  "forge.membership_checkout.pwyw_min": "(minimum {amount})",
+  "forge.membership_checkout.select_tier": "Select this tier",
   "forge.membership_checkout.submit": "Subscribe",
   "forge.membership_checkout.submitting": "Processing…",
   "forge.membership_checkout.title": "Join {tier_name}",
@@ -746,6 +804,7 @@
   "forge.membership_tiers.price_free": "Free",
   "forge.membership_tiers.price_monthly": "{amount}/mo",
   "forge.membership_tiers.price_pwyw": "Pay what you want from {amount}/mo",
+  "forge.membership_tiers.price_pwyw_yearly": "Pay what you want from {amount}/yr",
   "forge.membership_tiers.price_yearly": "{amount}/yr",
   "forge.membership_tiers.select": "Select",
   "forge.offer_button.buy_now": "Buy now",

package/src/ui/format/_tests/membershipPwyw.spec.ts

@@ -0,0 +1,185 @@
+import { describe, it, expect } from "vitest";
+import type { MembershipTier } from "../../../types/models";
+import {
+  clampMembershipAmount,
+  cycleCeiling,
+  cycleFloor,
+  cycleIsFree,
+  cycleIsOffered,
+  defaultChosenAmount,
+  defaultCycle,
+  offeredCycles,
+  refuseMembershipAmount,
+  resolveSubscriptionAmount,
+} from "../membershipPwyw";
+
+/**
+ * The membership money rules, away from React.
+ *
+ * Everything here decides either what a fan is CHARGED or which endpoint is
+ * called, and both have shipped wrong: a pay-what-you-want box that sent its
+ * initial zero to an endpoint that refuses anything not positive, and a
+ * yearly-only tier read as free because the default cycle was the literal
+ * "month".
+ */
+
+const tier = (overrides: Partial<MembershipTier> = {}): MembershipTier => ({
+  id: "tier-1",
+  name: "Inner Circle",
+  description: "The good stuff",
+  payWhatYouWant: false,
+  benefits: [],
+  ...overrides,
+});
+
+describe("cycleFloor", () => {
+  it("reads a pay-what-you-want tier's YEARLY minimum on the yearly cycle", () => {
+    // Monthly 5, yearly 50. Reading the monthly floor on a yearly subscription
+    // would let someone buy a whole year for the price of a month.
+    const t = tier({ payWhatYouWant: true, payWhatYouWantMinimum: 5, payWhatYouWantYearlyMinimum: 50 });
+
+    expect(cycleFloor(t, "month")).toBe(5);
+    expect(cycleFloor(t, "year")).toBe(50);
+  });
+
+  it("reads a fixed tier's own cycle price, which is the only amount the server takes", () => {
+    const t = tier({ priceMonthly: 10, priceYearly: 100 });
+
+    expect(cycleFloor(t, "month")).toBe(10);
+    expect(cycleFloor(t, "year")).toBe(100);
+  });
+
+  it("treats a missing, null or negative price as no price at all", () => {
+    expect(cycleFloor(tier({ priceMonthly: undefined }), "month")).toBe(0);
+    expect(cycleFloor(tier({ priceYearly: -4 }), "year")).toBe(0);
+  });
+});
+
+describe("offeredCycles / defaultCycle", () => {
+  it("REGRESSION: opens a YEARLY-ONLY tier on the yearly cycle", () => {
+    // The defect: the cycle defaulted to the literal "month", the monthly price
+    // was absent, and the tier was therefore read as FREE and activated through
+    // the free endpoint. The fan got the tier and the artist was never charged.
+    const t = tier({ priceYearly: 100 });
+
+    expect(offeredCycles(t)).toEqual({ month: false, year: true });
+    expect(defaultCycle(t)).toBe("year");
+    expect(cycleIsFree(t, defaultCycle(t))).toBe(false);
+  });
+
+  it("opens a pay-what-you-want tier with only a yearly minimum on the yearly cycle", () => {
+    const t = tier({ payWhatYouWant: true, payWhatYouWantYearlyMinimum: 60 });
+
+    expect(offeredCycles(t)).toEqual({ month: false, year: true });
+    expect(defaultCycle(t)).toBe("year");
+  });
+
+  it("prefers monthly when both are sold", () => {
+    expect(defaultCycle(tier({ priceMonthly: 10, priceYearly: 100 }))).toBe("month");
+  });
+
+  it("calls a tier with no price on either cycle free, and opens it on monthly", () => {
+    const t = tier();
+
+    expect(cycleIsOffered(t, "month")).toBe(false);
+    expect(cycleIsOffered(t, "year")).toBe(false);
+    expect(defaultCycle(t)).toBe("month");
+    expect(cycleIsFree(t, "month")).toBe(true);
+  });
+
+  it("never calls a pay-what-you-want tier free, whatever its minimums", () => {
+    // A PWYW tier is bought through the PAID endpoint even at its floor, so
+    // reading it as free would activate a membership with no charge behind it.
+    expect(cycleIsFree(tier({ payWhatYouWant: true, payWhatYouWantMinimum: 5 }), "month")).toBe(false);
+  });
+});
+
+describe("defaultChosenAmount", () => {
+  it("REGRESSION: opens the amount box at the floor, not at zero", () => {
+    // The defect: the box started at 0 and nothing ever seeded it, so the very
+    // first press of Subscribe sent `amount: 0` and the server answered
+    // `amount_must_be_positive`. Pay-what-you-want could not be bought at all.
+    const t = tier({ payWhatYouWant: true, payWhatYouWantMinimum: 25, payWhatYouWantYearlyMinimum: 250 });
+
+    expect(defaultChosenAmount(t, "month")).toBe(25);
+    expect(defaultChosenAmount(t, "year")).toBe(250);
+  });
+
+  it("leaves a fixed tier's box at zero, because it is never read", () => {
+    expect(defaultChosenAmount(tier({ priceMonthly: 10 }), "month")).toBe(0);
+  });
+});
+
+describe("clampMembershipAmount", () => {
+  const t = tier({ payWhatYouWant: true, payWhatYouWantMinimum: 20, payWhatYouWantMaximum: 100 });
+
+  it("lifts anything under the floor up to it", () => {
+    expect(clampMembershipAmount(t, "month", 5)).toBe(20);
+    expect(clampMembershipAmount(t, "month", 0)).toBe(20);
+    expect(clampMembershipAmount(t, "month", -3)).toBe(20);
+  });
+
+  it("treats an unparseable box (a cleared input) as the floor rather than NaN", () => {
+    expect(clampMembershipAmount(t, "month", Number(""))).toBe(20);
+    expect(clampMembershipAmount(t, "month", undefined)).toBe(20);
+  });
+
+  it("keeps a generous amount exactly as typed, ceiling and all", () => {
+    // The ceiling is display-only: neither the client app nor the server
+    // enforces one on a membership, and lowering the figure here would charge
+    // less than the total the fan just read.
+    expect(clampMembershipAmount(t, "month", 45)).toBe(45);
+    expect(clampMembershipAmount(t, "month", 500)).toBe(500);
+    expect(cycleCeiling(t, "month")).toBe(100);
+  });
+});
+
+describe("resolveSubscriptionAmount", () => {
+  it("ignores the amount box on a fixed tier", () => {
+    // A figure left over from a pay-what-you-want tier must not follow the fan
+    // onto a fixed one: the server rejects anything that is not exactly the
+    // cycle price, so this would be a checkout that always 400s.
+    const t = tier({ priceMonthly: 10, priceYearly: 100 });
+
+    expect(resolveSubscriptionAmount(t, "month", 999)).toBe(10);
+    expect(resolveSubscriptionAmount(t, "year", 999)).toBe(100);
+  });
+
+  it("sends the fan's own figure on a pay-what-you-want tier", () => {
+    const t = tier({ payWhatYouWant: true, payWhatYouWantMinimum: 5 });
+
+    expect(resolveSubscriptionAmount(t, "month", 12.5)).toBe(12.5);
+  });
+});
+
+describe("refuseMembershipAmount", () => {
+  it("refuses a pay-what-you-want figure under the floor, and names the floor", () => {
+    const t = tier({ payWhatYouWant: true, payWhatYouWantMinimum: 20 });
+
+    expect(refuseMembershipAmount(t, "month", 5)).toEqual({ reason: "below_minimum", minimum: 20 });
+  });
+
+  it("refuses a zero before the request rather than after the 400", () => {
+    // A pay-what-you-want tier whose floor is 0 passes the minimum check on 0
+    // and then fails `amount_must_be_positive` server-side, with the failure
+    // landing nowhere the fan can see.
+    const t = tier({ payWhatYouWant: true, payWhatYouWantMinimum: 0, payWhatYouWantYearlyMinimum: 60 });
+
+    expect(refuseMembershipAmount(t, "month", 0)).toEqual({ reason: "not_positive" });
+  });
+
+  it("passes a figure at the floor, and anything above it", () => {
+    const t = tier({ payWhatYouWant: true, payWhatYouWantMinimum: 20 });
+
+    expect(refuseMembershipAmount(t, "month", 20)).toBeNull();
+    expect(refuseMembershipAmount(t, "month", 21)).toBeNull();
+  });
+
+  it("passes a free cycle, which never sends an amount at all", () => {
+    expect(refuseMembershipAmount(tier(), "month", 0)).toBeNull();
+  });
+
+  it("passes a fixed paid cycle regardless of the box", () => {
+    expect(refuseMembershipAmount(tier({ priceMonthly: 10 }), "month", 0)).toBeNull();
+  });
+});