@tribe-nest/forge 3.34.0 → 3.35.0

package/src/ui/styled/_tests/AccountDashboardBookingCall.spec.tsx

@@ -27,6 +27,7 @@ import { AccountDashboard } from "../AccountDashboard";
 const PROFILE_ID = "profile-1";
 const ACCOUNT_ID = "account-1";
 const MINUTE = 60_000;
+const HOUR = 60 * MINUTE;
 
 const member = {
   id: ACCOUNT_ID,
@@ -59,6 +60,9 @@ const booking = (overrides: Partial<MyBooking> = {}): MyBooking => {
     cancellationOutcome: null,
     createdAt: "2026-01-01T00:00:00.000Z",
     coachingBookingSlotId: "slot-1",
+    // The call's address, written when the booking was confirmed. A real
+    // confirmed video booking always carries one.
+    videoCallId: "call-1",
     sessionStartTime: start.toISOString(),
     sessionEndTime: end.toISOString(),
     coachingProductId: "product-1",
@@ -117,10 +121,34 @@ describe("AccountDashboard: the way into a coaching video call", () => {
 
     expect(html).toContain("Video session");
     expect(html).toContain("Join video call");
+    // A LINK to the call's own page, at the same address the coach opens from
+    // the dashboard. It used to mount the room inline, between two rows of a
+    // list, which is not what a call looks like anywhere else.
+    expect(html).toContain('href="/i/video-calls/call-1"');
     // The line still says where the session is; the control is in addition.
     expect(html).toContain("Video call on this site");
   });
 
+  it("draws no control for a session with no call address, but still says it is a video call", () => {
+    /**
+     * Only reachable for a booking confirmed before calls became addressable,
+     * since a confirmation now writes the record. A dead button would be worse
+     * than none, and the row above still names the session as a video call.
+     */
+    const html = render([booking({ videoCallId: null })]);
+
+    expect(html).toContain("Video call on this site");
+    expect(html).not.toContain("Join video call");
+  });
+
+  it("still says when the room opens even without a call address", () => {
+    // The window copy is about the SESSION, so it must not depend on whether a
+    // room record exists. This is the branch my first attempt broke.
+    const html = render([booking({ videoCallId: null, sessionStartTime: new Date(Date.now() + 6 * HOUR).toISOString() })]);
+
+    expect(html).toMatch(/opens|Opens/);
+  });
+
   it("says when the room opens, rather than offering a Join that would 409", () => {
     const start = new Date(Date.now() + 3 * 60 * MINUTE);
     const html = render([

package/src/ui/styled/forge-utilities.css

@@ -204,6 +204,9 @@
     .shrink-0 {
       flex-shrink: 0;
     }
+    .grow {
+      flex-grow: 1;
+    }
     .transform {
       transform: var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,);
     }

package/src/utils/structuredData.ts

@@ -10,22 +10,15 @@ export function buildOrganizationSchema(webPage: WebPage, origin: string) {
     "@type": "Organization",
     name: webPage.profile.name,
     url: origin,
-    ...(webPage.themeSettings.header?.logo
-      ? { logo: webPage.themeSettings.header.logo }
-      : {}),
-    ...(socialLinks.length > 0
-      ? { sameAs: socialLinks.map((l: { href: string }) => l.href).filter(Boolean) }
-      : {}),
+    ...(webPage.themeSettings.header?.logo ? { logo: webPage.themeSettings.header.logo } : {}),
+    ...(socialLinks.length > 0 ? { sameAs: socialLinks.map((l: { href: string }) => l.href).filter(Boolean) } : {}),
   };
 }
 
 /**
  * Generates WebPage JSON-LD.
  */
-export function buildWebPageSchema(
-  webPage: WebPage,
-  canonicalUrl: string,
-) {
+export function buildWebPageSchema(webPage: WebPage, canonicalUrl: string) {
   return {
     "@context": "https://schema.org",
     "@type": "WebPage",
@@ -181,10 +174,7 @@ export function buildEntitySchema(input: EntitySchemaInput): Record<string, unkn
 
   const { aggregate } = input;
   const hasRatings =
-    !!aggregate &&
-    aggregate.reviewCount > 0 &&
-    Number.isFinite(aggregate.avgRating) &&
-    aggregate.avgRating > 0;
+    !!aggregate && aggregate.reviewCount > 0 && Number.isFinite(aggregate.avgRating) && aggregate.avgRating > 0;
 
   const reviews = (input.reviews ?? [])
     .filter((r) => r.rating >= 1 && r.rating <= 5)
@@ -439,12 +429,93 @@ export function buildServiceSchema(
     aggregate: service.reviewAggregate ?? null,
     reviews: options.reviews,
     offer:
-      options.currency && price !== undefined
-        ? { currency: options.currency, price, availability: "InStock" }
-        : null,
+      options.currency && price !== undefined ? { currency: options.currency, price, availability: "InStock" } : null,
   });
 }
 
+/**
+ * Structural view of `GET /public/films/:slug`. `PublicFilmDetail` satisfies it.
+ *
+ * Deliberately narrow, and deliberately NOT the whole payload: JSON-LD is
+ * emitted into an anonymous SSR document, so anything named here is something a
+ * crawler and a signed-out visitor both get to read. Nothing about a rental,
+ * a session or an episode's storage belongs in it.
+ */
+export interface FilmSchemaSource {
+  kind: "film" | "series";
+  title: string;
+  description?: string | null;
+  cover?: { url: string } | null;
+  currency: string;
+  rentalPriceCents?: number | null;
+  publishedAt?: string | null;
+  episodes?: { durationSec?: number | null }[] | null;
+}
+
+/** ISO 8601 duration (`PT1H42M`) from whole seconds, or undefined when unknown. */
+const isoDuration = (seconds?: number | null): string | undefined => {
+  if (seconds == null || !Number.isFinite(seconds) || seconds <= 0) return undefined;
+  const whole = Math.floor(seconds);
+  const hours = Math.floor(whole / 3600);
+  const minutes = Math.round((whole % 3600) / 60);
+  if (!hours && !minutes) return undefined;
+  return `PT${hours ? `${hours}H` : ""}${minutes ? `${minutes}M` : ""}`;
+};
+
+/**
+ * schema.org/Movie or /TVSeries for a rentable title.
+ *
+ * Built by hand rather than through `buildEntitySchema`, whose `type` union is
+ * closed over the three reviewable sellables. Widening that union to carry two
+ * types that have no review surface would make every caller of it responsible
+ * for cases it can never see.
+ *
+ * The offer is the title's rental price, which is the only price there is: a
+ * rental always buys the whole title. There is no cheaper way in to quote, and
+ * a title with no price gets no `offers` node rather than a free one.
+ */
+export function buildFilmSchema(
+  film: FilmSchemaSource | null | undefined,
+  options: SellableSchemaOptions = {},
+): Record<string, unknown> | null {
+  const name = film?.title?.trim();
+  if (!film || !name) return null;
+
+  const priceCents =
+    typeof film.rentalPriceCents === "number" && Number.isFinite(film.rentalPriceCents) ? film.rentalPriceCents : null;
+  const currency = options.currency ?? film.currency;
+  const description = toSchemaText(film.description);
+  // A film's runtime is its single episode's. A series has no one runtime, so it
+  // gets none rather than an invented average.
+  const duration = film.kind === "film" ? isoDuration(film.episodes?.[0]?.durationSec) : undefined;
+
+  return {
+    "@context": "https://schema.org",
+    "@type": film.kind === "series" ? "TVSeries" : "Movie",
+    name,
+    ...(description ? { description } : {}),
+    ...(film.cover?.url ? { image: film.cover.url } : {}),
+    ...(options.url ? { url: options.url } : {}),
+    ...(options.brand ? { provider: { "@type": "Organization", name: options.brand } } : {}),
+    ...(film.publishedAt ? { datePublished: film.publishedAt } : {}),
+    ...(duration ? { duration } : {}),
+    ...(film.kind === "series" && film.episodes?.length ? { numberOfEpisodes: film.episodes.length } : {}),
+    ...(currency && priceCents != null
+      ? {
+          offers: {
+            "@type": "Offer",
+            priceCurrency: currency,
+            price: money(priceCents / 100),
+            availability: "https://schema.org/InStock",
+            // A rental, not a sale. Saying so is what keeps a $2 line from
+            // reading as the price of owning the film.
+            category: "Rental",
+          },
+        }
+      : {}),
+  };
+}
+
 /**
  * The `scripts` entry a TanStack `head()` needs for a JSON-LD node. Returns an
  * empty array for a null schema, so it can be spread unconditionally: