@tribe-nest/forge 3.60.0 → 3.61.0

package/src/data/queries/useMyTickets.ts

@@ -1,5 +1,5 @@
 import { useForge } from "../../provider/ForgeProvider";
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import type { PaginatedData } from "../../types/models";
 
 /**
@@ -313,3 +313,26 @@ export function useCancelMyTicket() {
     },
   });
 }
+
+/**
+ * Every ticket, a page at a time, for a list with a "Show more" button.
+ *
+ * Under the same `my-tickets` key prefix as `useMyTickets`, so the cancel and
+ * transfer mutations that invalidate that prefix refresh this too.
+ */
+export function useMyTicketsPaged(accountId?: string, limit = 20) {
+  const { client, profileId } = useForge();
+  return useInfiniteQuery({
+    queryKey: ["my-tickets", accountId, profileId, "paged", limit],
+    initialPageParam: 1,
+    queryFn: async ({ pageParam }) => {
+      const res = await client.get("/public/events/my-tickets", { params: { profileId, page: pageParam, limit } });
+      return res.data as PaginatedData<MyTicket>;
+    },
+    getNextPageParam: (last, pages) => {
+      const loaded = pages.reduce((sum, p) => sum + p.data.length, 0);
+      return loaded < last.total && last.data.length > 0 ? pages.length + 1 : undefined;
+    },
+    enabled: !!accountId && !!profileId && !!client,
+  });
+}

package/src/data/queries/useNotifications.ts

@@ -3,7 +3,7 @@ import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { useCallback, useEffect, useState } from "react";
 
 /**
- * Member notification headless hooks — the FROZEN public contract that the
+ * Member notification headless hooks: the FROZEN public contract that the
  * apps/client PWA and every generated custom-code site consume. Speaks ONLY the
  * `/public/notifications/*` API (see docs/archive/shipped/membership-notifications-initiative.md
  * "API surface"). Moved here from apps/client so custom-code sites get push
@@ -56,6 +56,10 @@ export interface NotificationInboxItem {
     url?: string;
     actorName?: string;
     actorAccountId?: string;
+    /** A `mod` notice about the member's own post or reply: what the moderator decided. */
+    outcome?: "approved" | "rejected";
+    /** The moderator's reason for a rejection, when one was given. */
+    reason?: string | null;
   } | null;
 }
 
@@ -218,7 +222,7 @@ export function useNotificationUnreadCount(enabled = true) {
   });
 }
 
-/** Mark notifications read — omit ids to mark ALL unread as read. */
+/** Mark notifications read. Omit ids to mark ALL unread as read. */
 export function useMarkNotificationsRead() {
   const { client, profileId } = useForge();
   const queryClient = useQueryClient();

package/src/data/queries/useOrders.ts

@@ -1,4 +1,5 @@
 import { useForge } from "../../provider/ForgeProvider";
+import { readMetaSignals } from "../../utils/metaEvents";
 import { useMutation } from "@tanstack/react-query";
 
 /**
@@ -74,7 +75,7 @@ export function useCreateOrder() {
 
   return useMutation<CreateOrderResult, unknown, CreateOrderInput>({
     mutationFn: async (input) => {
-      const res = await client.post("/public/orders", { ...input, profileId });
+      const res = await client.post("/public/orders", { ...input, profileId, metaSignals: readMetaSignals() });
       return res.data;
     },
   });

package/src/data/queries/usePWA.ts

@@ -1,7 +1,8 @@
 import { useCallback, useEffect, useState } from "react";
+import { shareRuntimeValue } from "../../runtime/registry";
 
 /**
- * Headless PWA install-prompt hook — the versioned Forge primitive that powers
+ * Headless PWA install-prompt hook: the versioned Forge primitive that powers
  * `<InstallBanner/>` (forge/ui) and any custom install UI on a code site. Ported
  * from apps/client/src/lib/hooks/usePWA.ts, plus iOS + standalone detection
  * (Safari never fires `beforeinstallprompt`, so iOS needs the manual
@@ -22,7 +23,7 @@ export interface InstallPromptState {
   isInstallable: boolean;
   /** The app is running installed (standalone display-mode or iOS standalone). */
   isInstalled: boolean;
-  /** iOS Safari — no `beforeinstallprompt`; show the Add-to-Home-Screen guide. */
+  /** iOS Safari has no `beforeinstallprompt`: show the Add-to-Home-Screen guide. */
   isIOS: boolean;
   /** Currently rendered in standalone (installed) display mode. */
   isStandalone: boolean;
@@ -47,8 +48,108 @@ function detectStandalone(): boolean {
   return !!mm || iosStandalone;
 }
 
+// ---- The captured install prompt, shared ----------------------------------
+//
+// The browser fires `beforeinstallprompt` ONCE per page load, usually soon after
+// it. A listener added later (a prompt mounted after the fan joins a community)
+// would never hear it, so the event is captured the first time anything asks,
+// and every reader shares the one captured event.
+//
+// Shared through the runtime registry, not a module variable: a site and the
+// hosted `/i/` pages bundle each carry a copy of Forge, and the site's copy
+// (`<PwaRegistration>`, at the root) is the one that hears the event.
+
+interface InstallPromptStore {
+  prompt: BeforeInstallPromptEvent | null;
+  installed: boolean;
+  capturing: boolean;
+  listeners: Set<() => void>;
+}
+
+const store = (): InstallPromptStore =>
+  shareRuntimeValue<InstallPromptStore>("state:pwa-install-prompt", () => ({
+    prompt: null,
+    installed: false,
+    capturing: false,
+    listeners: new Set(),
+  }));
+
+const notifyPrompt = () => store().listeners.forEach((listener) => listener());
+
+/**
+ * Start listening for `beforeinstallprompt` (and `appinstalled`). Idempotent and
+ * SSR-safe. `<PwaRegistration enabled>` calls it at mount so the event is held
+ * from the first page a visitor sees.
+ */
+export function captureInstallPrompt(): void {
+  const state = store();
+  if (state.capturing || typeof window === "undefined") return;
+  state.capturing = true;
+  window.addEventListener("beforeinstallprompt", (event: Event) => {
+    event.preventDefault();
+    store().prompt = event as BeforeInstallPromptEvent;
+    notifyPrompt();
+  });
+  window.addEventListener("appinstalled", () => {
+    store().prompt = null;
+    store().installed = true;
+    notifyPrompt();
+  });
+}
+
+/** True when a native install prompt is held and can be shown. */
+export function hasStoredInstallPrompt(): boolean {
+  return !!store().prompt;
+}
+
+/** True once the app was installed during this page's life. */
+export function wasInstalledThisSession(): boolean {
+  return store().installed;
+}
+
+/** Be told when the held prompt arrives, is used, or the app is installed. */
+export function subscribeInstallPrompt(listener: () => void): () => void {
+  store().listeners.add(listener);
+  return () => {
+    store().listeners.delete(listener);
+  };
+}
+
+/**
+ * Show the held native prompt. Resolves true when the visitor accepted. A
+ * prompt can be shown once, so it is released either way.
+ */
+export async function promptStoredInstall(): Promise<boolean> {
+  const state = store();
+  const event = state.prompt;
+  if (!event) return false;
+  state.prompt = null;
+  notifyPrompt();
+  try {
+    await event.prompt();
+    const { outcome } = await event.userChoice;
+    if (outcome === "accepted") {
+      state.installed = true;
+      notifyPrompt();
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+/** Test seam: forget whatever was captured, or hold `event` as if the browser had fired it. */
+export function resetInstallPromptForTests(event: Event | null = null): void {
+  const state = store();
+  state.prompt = event as BeforeInstallPromptEvent | null;
+  state.installed = false;
+  notifyPrompt();
+}
+
+export { detectIOS as isIOSDevice, detectStandalone as isStandaloneDisplay };
+
 export function useInstallPrompt(): InstallPromptState {
-  const [deferredPrompt, setDeferredPrompt] = useState<BeforeInstallPromptEvent | null>(null);
   const [isInstallable, setIsInstallable] = useState(false);
   const [isInstalled, setIsInstalled] = useState(false);
   const [isIOS, setIsIOS] = useState(false);
@@ -61,41 +162,16 @@ export function useInstallPrompt(): InstallPromptState {
     setIsStandalone(standalone);
     if (standalone) setIsInstalled(true);
 
-    const handleBeforeInstallPrompt = (e: Event) => {
-      e.preventDefault();
-      setDeferredPrompt(e as BeforeInstallPromptEvent);
-      setIsInstallable(true);
-    };
-    const handleAppInstalled = () => {
-      setIsInstalled(true);
-      setIsInstallable(false);
-      setDeferredPrompt(null);
-    };
-
-    window.addEventListener("beforeinstallprompt", handleBeforeInstallPrompt);
-    window.addEventListener("appinstalled", handleAppInstalled);
-    return () => {
-      window.removeEventListener("beforeinstallprompt", handleBeforeInstallPrompt);
-      window.removeEventListener("appinstalled", handleAppInstalled);
+    captureInstallPrompt();
+    const sync = () => {
+      setIsInstallable(hasStoredInstallPrompt());
+      if (wasInstalledThisSession()) setIsInstalled(true);
     };
+    sync();
+    return subscribeInstallPrompt(sync);
   }, []);
 
-  const promptInstall = useCallback(async () => {
-    if (!deferredPrompt) return false;
-    try {
-      await deferredPrompt.prompt();
-      const { outcome } = await deferredPrompt.userChoice;
-      if (outcome === "accepted") {
-        setIsInstalled(true);
-        setIsInstallable(false);
-        setDeferredPrompt(null);
-        return true;
-      }
-      return false;
-    } catch {
-      return false;
-    }
-  }, [deferredPrompt]);
+  const promptInstall = useCallback(() => promptStoredInstall(), []);
 
   return { isInstallable, isInstalled, isIOS, isStandalone, promptInstall };
 }

package/src/data/queries/useSiteApp.ts

@@ -0,0 +1,130 @@
+import { useEffect, useState } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { useForge } from "../../provider/ForgeProvider";
+import { internalPath } from "../../runtime/pages";
+
+/**
+ * The site app: the installable app every website is (one per origin).
+ *
+ * Speaks `GET /public/websites/app?host=<host>`, which answers for the website
+ * that owns the host the visitor is on. Contract:
+ * docs/proposals/site-app-and-website-menu.md, sections 2 and 3.
+ */
+
+/** The built-in sections of the app home, in their default order. */
+export const SITE_APP_SECTION_KEYS = [
+  "needs_you",
+  "portal",
+  "communities",
+  "coming_up",
+  "learning",
+  "explore_communities",
+  "events",
+  "courses",
+  "shop",
+] as const;
+
+export type SiteAppSectionKey = (typeof SITE_APP_SECTION_KEYS)[number];
+
+/** What may sit in the app bar between Home and More. */
+export const SITE_APP_BAR_KEYS = ["communities", "portal", "inbox", "events", "courses", "shop"] as const;
+
+export type SiteAppBarKey = (typeof SITE_APP_BAR_KEYS)[number];
+
+/** How many configured items fit between Home and More. */
+export const SITE_APP_BAR_MAX_ITEMS = 3;
+
+export type SiteAppHomeSection =
+  | { type: "builtin"; key: SiteAppSectionKey; visible: boolean }
+  | { type: "link"; id: string; label: string; href: string; visible: boolean };
+
+/** The public answer, exactly as section 3 of the contract shapes it. */
+export interface SiteApp {
+  websiteId: string;
+  profileId: string;
+  appName: string;
+  shortName: string;
+  iconUrl: string | null;
+  themeColor: string | null;
+  backgroundColor: string | null;
+  /** `/i/app`, or the creator's own start page. Home everywhere. */
+  startUrl: string;
+  /** Only the VISIBLE sections, in the configured order. */
+  homeSections: SiteAppHomeSection[];
+  barItems: SiteAppBarKey[];
+  installPrompt: boolean;
+  pushPrompt: boolean;
+  activeVersionId: string | null;
+}
+
+/** Where the app starts when the creator has not chosen a page of their own. */
+export const SITE_APP_DEFAULT_START = internalPath("app");
+
+/** Visible by default; `events` and `courses` are off until the creator turns them on. */
+const DEFAULT_HIDDEN: ReadonlySet<SiteAppSectionKey> = new Set(["events", "courses"]);
+
+/** The visible home sections when no settings answer: the contract's defaults. */
+export const SITE_APP_DEFAULT_SECTIONS: readonly SiteAppHomeSection[] = SITE_APP_SECTION_KEYS.filter(
+  (key) => !DEFAULT_HIDDEN.has(key),
+).map((key) => ({ type: "builtin", key, visible: true }) as const);
+
+export const SITE_APP_DEFAULT_BAR: readonly SiteAppBarKey[] = ["communities", "portal", "inbox"];
+
+export const siteAppKeys = {
+  byHost: (host: string | null) => ["site-app", host] as const,
+};
+
+/**
+ * The host the visitor is on, read after mount.
+ *
+ * Not during render: the server has no `window`, and reading it there would
+ * render one thing on the server and another on the first client pass.
+ */
+export function useCurrentHost(): string | null {
+  const [host, setHost] = useState<string | null>(null);
+  useEffect(() => {
+    if (typeof window !== "undefined") setHost(window.location.host || null);
+  }, []);
+  return host;
+}
+
+/**
+ * This website's app settings, for the host the visitor is on.
+ *
+ * An unknown host (a preview, the edit sandbox) is a 404, which is an answer
+ * rather than a fault: it is not retried, and every reader falls back to the
+ * defaults (`useAppHomeHref` to `/i/app`).
+ */
+export function useSiteApp(opts: { host?: string | null; enabled?: boolean } = {}) {
+  const { client } = useForge();
+  const currentHost = useCurrentHost();
+  const host = opts.host ?? currentHost;
+  return useQuery<SiteApp>({
+    queryKey: siteAppKeys.byHost(host),
+    queryFn: async () => (await client.get("/public/websites/app", { params: { host } })).data as SiteApp,
+    enabled: !!client && !!host && opts.enabled !== false,
+    retry: false,
+    // Settings change rarely, and every page with an app bar reads them.
+    staleTime: 5 * 60_000,
+  });
+}
+
+/**
+ * Where "Home" is: the creator's start page when they chose one, else `/i/app`.
+ *
+ * The Home rule (contract section 4): the app bar's Home, the community
+ * header's logo, and where sign-in lands by default all read this, so a creator
+ * who moves Home moves it everywhere at once.
+ */
+export function useAppHomeHref(): string {
+  const { data } = useSiteApp();
+  return resolveAppHomeHref(data);
+}
+
+/** The pure half of `useAppHomeHref`, for a caller that already holds the settings. */
+export function resolveAppHomeHref(app: Pick<SiteApp, "startUrl"> | null | undefined): string {
+  const start = app?.startUrl?.trim();
+  // Only a root-relative path is a Home: anything else would send the member off-site.
+  if (!start || !start.startsWith("/") || start.startsWith("//")) return SITE_APP_DEFAULT_START;
+  return start;
+}

package/src/data/queries/useSubscriptions.ts

@@ -1,4 +1,5 @@
 import { useForge } from "../../provider/ForgeProvider";
+import { readMetaSignals } from "../../utils/metaEvents";
 import { useOptionalCommunityContext } from "../../contexts/CommunityContext";
 import { useMutation } from "@tanstack/react-query";
 import { usePublicAuth } from "../../contexts/PublicAuthContext";
@@ -68,7 +69,11 @@ export function useCreateSubscription() {
 
   return useMutation<CreateSubscriptionResult, unknown, CreateSubscriptionInput>({
     mutationFn: async (body) => {
-      const res = await client.post("/public/payments/subscriptions", { ...body, profileId });
+      const res = await client.post("/public/payments/subscriptions", {
+        ...body,
+        profileId,
+        metaSignals: readMetaSignals(),
+      });
       return res.data;
     },
   });