@bygghammar/cms-platform 0.93.0 → 0.95.0

package/src/cms/page-visibility.ts

@@ -0,0 +1,206 @@
+/**
+ * Page listing and the public policy built from it.
+ *
+ * Two independent properties decide how a page appears to visitors:
+ *
+ * - **Publication** — can a visitor open it at all? Publication windows answer
+ *   that (`cms/page-publication`); Unpublish closes them.
+ * - **Listing** — is it advertised? A `listed` page appears in menus, footers
+ *   and the sitemap like any other. A `link-only` page is just as reachable,
+ *   but only for someone who has its address: it is left out of navigation and
+ *   the sitemap and asks search engines not to index it.
+ *
+ * Listing never publishes, unpublishes, replaces or reschedules anything, and
+ * nothing that publishes changes listing. It is not access control either:
+ * a link-only address can be shared, guessed or found, and `noindex` is a
+ * request to crawlers, not a removal from results that already exist.
+ */
+import type { PublicationState } from "./page-publication";
+import { isPubliclyVisible } from "./page-publication";
+
+export const PAGE_LISTINGS = ["listed", "link-only"] as const;
+export type PageListing = (typeof PAGE_LISTINGS)[number];
+
+/** Pages are listed unless somebody decided otherwise. */
+export const DEFAULT_PAGE_LISTING: PageListing = "listed";
+
+export function normalizePageListing(raw: unknown): PageListing {
+  return raw === "link-only" ? "link-only" : "listed";
+}
+
+/** The three answers the screens lead with, in a visitor's terms. */
+export type PageVisibility = "published" | "link-only" | "offline";
+
+export const PAGE_VISIBILITY_LABELS: Record<PageVisibility, string> = {
+  published: "Published",
+  "link-only": "Link only",
+  offline: "Offline",
+};
+
+export const PAGE_VISIBILITY_DESCRIPTIONS: Record<PageVisibility, string> = {
+  published: "Visible on the public website and listed in menus, footer and sitemap.",
+  "link-only":
+    "Visible to anyone who has the exact address, but left out of menus, footer and sitemap, " +
+    "and search engines are asked not to index it. It is not private: the address can be shared.",
+  offline: "Not on the public website. Visitors get “page not found”.",
+};
+
+/**
+ * The headline answer for one page, from both properties.
+ *
+ * Only the headline: schedules and editorial status keep their own badges,
+ * because "offline" says nothing about a window that opens tomorrow.
+ */
+export function pageVisibility(publication: PublicationState, listing: PageListing): PageVisibility {
+  if (!isPubliclyVisible(publication)) return "offline";
+  return listing === "link-only" ? "link-only" : "published";
+}
+
+/* ------------------------------------------------------------------------ */
+/* Confirmation copy                                                         */
+/* ------------------------------------------------------------------------ */
+
+export type VisibilityConfirmation = {
+  title: string;
+  body: string[];
+  confirmLabel: string;
+};
+
+/** What Make link-only does to this page, said before it happens. */
+export function linkOnlyConfirmation(page: {
+  name: string;
+  path: string;
+  live: boolean;
+}): VisibilityConfirmation {
+  return {
+    title: `Make “${page.name}” link-only?`,
+    body: [
+      page.live
+        ? `${page.path} stays online for anyone who has the address.`
+        : `${page.path} is offline now; once published it will only be reachable by its address.`,
+      "It disappears from the menu, the footer and the sitemap, and search engines are asked not to index it.",
+      "This is not a password: anyone with the link can open it, and it can be shared.",
+    ],
+    confirmLabel: "Make link-only",
+  };
+}
+
+/** What Show on website does: listing only, never a publish. */
+export function showOnWebsiteConfirmation(page: {
+  name: string;
+  path: string;
+  live: boolean;
+}): VisibilityConfirmation {
+  return {
+    title: `Show “${page.name}” on the website?`,
+    body: [
+      "Menu and footer links to it reappear, it is added to the sitemap, and search engines may index it.",
+      page.live
+        ? `${page.path} is already online; nothing about its content changes.`
+        : `${page.path} is offline: this does not publish it. It is listed again once it is published.`,
+    ],
+    confirmLabel: "Show on website",
+  };
+}
+
+/** The extra sentences Unpublish adds to the existing schedule-aware warning. */
+export function unpublishConsequences(page: { path: string; listing: PageListing }): string[] {
+  const lines = [
+    `Visitors to ${page.path} will get “page not found”.`,
+    "Menu and footer links to it are hidden until it is published again; the menu itself is not changed.",
+  ];
+  if (page.listing === "link-only") {
+    lines.push("It stays link-only, so publishing it again will not list it.");
+  }
+  return lines;
+}
+
+/** Why a protected page offers neither action. */
+export const PROTECTED_PAGE_REASON =
+  "This page is protected: the start page and the contact page always stay published and listed.";
+
+/* ------------------------------------------------------------------------ */
+/* Public policy                                                             */
+/* ------------------------------------------------------------------------ */
+
+/** One page, as public rendering needs to know it. */
+export type PolicyPage = {
+  id: string;
+  key: string;
+  /** Can a visitor open it right now (publication windows, trash excluded)? */
+  live: boolean;
+  listing: PageListing;
+  /** Booking links in this page's own content stay while booking is off. */
+  bookingException: boolean;
+};
+
+/**
+ * Everything public rendering decides from, read once on the server.
+ *
+ * `known: false` is a read that failed. It is never a default: every question
+ * below then gets its restrictive answer — booking hidden, nothing indexable,
+ * no page reported offline (a failed read is not proof a page is gone).
+ */
+export type PublicPolicySnapshot = {
+  known: boolean;
+  bookingEnabled: boolean;
+  pages: PolicyPage[];
+  /** The next instant any of this changes on its own (a publication boundary). */
+  revalidateAt: number | null;
+};
+
+export const UNKNOWN_PUBLIC_POLICY: PublicPolicySnapshot = Object.freeze({
+  known: false,
+  bookingEnabled: false,
+  pages: [],
+  revalidateAt: null,
+}) as PublicPolicySnapshot;
+
+export function policyPage(policy: PublicPolicySnapshot, key: string): PolicyPage | null {
+  return policy.pages.find((page) => page.key === key) ?? null;
+}
+
+/** May search engines index this page? Only a live, listed page, read successfully. */
+export function pageIsIndexable(policy: PublicPolicySnapshot, key: string): boolean {
+  const page = policyPage(policy, key);
+  return policy.known && page !== null && page.live && page.listing === "listed";
+}
+
+/**
+ * Is this page positively known to be offline?
+ *
+ * Only a successful read that found the page and found it not live says so.
+ * An unknown page (no CMS row) or a failed read is not offline — the caller
+ * renders what it always rendered, or reports the error.
+ */
+export function pageIsKnownOffline(policy: PublicPolicySnapshot, key: string): boolean {
+  if (!policy.known) return false;
+  const page = policyPage(policy, key);
+  return page !== null && !page.live;
+}
+
+/** Booking in site-wide chrome: header button, menu, footer, popups. */
+export function chromeBookingVisible(policy: PublicPolicySnapshot): boolean {
+  return policy.known && policy.bookingEnabled;
+}
+
+/** Booking in one page's own content: on when booking is on, or the page is an exception. */
+export function pageBookingVisible(policy: PublicPolicySnapshot, key: string | null): boolean {
+  if (!policy.known) return false;
+  if (policy.bookingEnabled) return true;
+  return key !== null && policyPage(policy, key)?.bookingException === true;
+}
+
+export type HiddenPageReason = "offline" | "link-only";
+
+/** Pages navigation must not point at, and why. */
+export function unlistedPages(
+  policy: PublicPolicySnapshot,
+): Array<{ key: string; reason: HiddenPageReason }> {
+  const out: Array<{ key: string; reason: HiddenPageReason }> = [];
+  for (const page of policy.pages) {
+    if (!page.live) out.push({ key: page.key, reason: "offline" });
+    else if (page.listing === "link-only") out.push({ key: page.key, reason: "link-only" });
+  }
+  return out;
+}

package/src/config/modules.ts

@@ -23,6 +23,8 @@ import {
   MessageSquareQuote,
 } from "lucide-react";
 
+import { POPUP_PACKAGE } from "../popups/package-name";
+
 /**
  * Every module a site can switch on.
  *
@@ -90,6 +92,14 @@ export type CmsModuleDefinition = {
    * enabled, so a disabled module mounts nothing.
    */
   readonly hasPublicRuntime?: boolean;
+  /**
+   * A separately published first-party package the module's runtime is built
+   * on, beyond the CMS package itself. The version screen reports its installed
+   * and published versions; every other module ships inside the CMS package and
+   * updates with it. Naming a package here also allows the server to look it up
+   * in the public registry, so only first-party packages belong here.
+   */
+  readonly package?: `@bygghammar/${string}`;
 };
 
 /**
@@ -145,6 +155,7 @@ export const CMS_MODULES = [
     nav: { path: "/popups", label: "Popups", icon: MessageSquare },
     requiresRole: "staff",
     hasPublicRuntime: true,
+    package: POPUP_PACKAGE,
   },
 ] as const satisfies readonly CmsModuleDefinition[];
 

package/src/html/sanitize-html.ts

@@ -114,7 +114,7 @@ const NAMED_REFERENCES: Record<string, string> = {
  * was checked: `&#106;avascript:` is judged as `javascript:`, and an
  * undecoded `javascript&colon;` never becomes one.
  */
-function decodeAttr(value: string): string {
+export function decodeAttr(value: string): string {
   return value.replace(
     /&(?:#([0-9]{1,7})|#[xX]([0-9a-fA-F]{1,6})|([a-zA-Z][a-zA-Z0-9]{0,31}));/g,
     (reference, decimal?: string, hex?: string, name?: string) => {

package/src/navigation/visibility.ts

@@ -0,0 +1,235 @@
+/**
+ * Which saved menu and footer links a visitor is shown right now.
+ *
+ * Saved navigation is never edited by a page changing state: an item pointing
+ * at a page that is offline or link-only is simply not rendered, and comes back
+ * by itself when the page is published or listed again. The same goes for
+ * booking links while booking is switched off.
+ *
+ * Only links positively known to point at such a page are hidden. External
+ * links, `#fragment` links, `mailto:`/`tel:` and every internal address the CMS
+ * does not know about are left alone — an address missing from the CMS list is
+ * a route the site serves some other way, not an offline page.
+ */
+import { isBookingHref } from "../cms/booking-links";
+import type { HiddenPageReason } from "../cms/page-visibility";
+import { normalizeOrigin, normalizeRoutePath } from "../site/route-index";
+import type { NavigationItem } from "./index";
+
+/** Why a saved link is not shown. */
+export type HiddenLinkReason = HiddenPageReason | "booking" | "unknown";
+
+export const HIDDEN_LINK_REASONS: Record<HiddenLinkReason, string> = {
+  offline: "Not shown on the site: the page it links to is offline.",
+  "link-only": "Not shown on the site: the page it links to is link-only.",
+  booking: "Not shown on the site: booking is switched off in Site settings.",
+  unknown: "Not shown right now: the site could not read which pages are public.",
+};
+
+/**
+ * What the chrome needs to decide, in a serializable shape a server can hand
+ * to the browser with the page.
+ */
+export type LinkVisibilityPolicy = {
+  /** False when the server could not read the policy: see {@link linkHideReason}. */
+  known: boolean;
+  /** Booking links in site-wide chrome (menu, footer, header button). */
+  bookingVisible: boolean;
+  /** Normalized served paths of unlisted pages, every locale and alias. */
+  hiddenPaths: Readonly<Record<string, HiddenPageReason>>;
+  /** Origins that are this site, for absolute links written with the domain. */
+  origins: readonly string[];
+  /** Locale prefixes, so `/EN/...` and `/en/...` compare equal. */
+  locales?: readonly string[];
+};
+
+/** No filtering at all: what screens without a public policy render with. */
+export const OPEN_LINK_POLICY: LinkVisibilityPolicy = Object.freeze({
+  known: true,
+  bookingVisible: true,
+  hiddenPaths: Object.freeze({}),
+  origins: Object.freeze([]) as readonly string[],
+});
+
+/**
+ * The site path an address leads to, or null when it leads off the site (or
+ * is not a navigable path at all).
+ */
+export function internalPathOf(
+  href: string,
+  policy: Pick<LinkVisibilityPolicy, "origins" | "locales">,
+): string | null {
+  const value = href.trim();
+  if (!value || value.startsWith("#")) return null;
+  const pathPolicy = { locales: policy.locales ?? [] };
+  if (value.startsWith("/") && !value.startsWith("//")) {
+    return normalizeRoutePath(value, pathPolicy);
+  }
+  const absolute = value.startsWith("//") ? `https:${value}` : value;
+  if (!/^https?:\/\//i.test(absolute)) return null;
+  let url: URL;
+  try {
+    url = new URL(absolute);
+  } catch {
+    return null;
+  }
+  const own = new Set(policy.origins.map((origin) => normalizeOrigin(origin)).filter(Boolean));
+  if (!own.has(url.origin)) return null;
+  return normalizeRoutePath(url.pathname, pathPolicy);
+}
+
+/** Why this saved link is hidden, or null when it is shown. */
+export function linkHideReason(href: string, policy: LinkVisibilityPolicy): HiddenLinkReason | null {
+  if (!policy.bookingVisible && isBookingHref(href)) return "booking";
+  const path = internalPathOf(href, policy);
+  if (path === null) return null;
+  /*
+   * A policy that could not be read hides every internal page link except the
+   * front page, rather than showing links to pages that may be offline or
+   * link-only. The pages themselves come from the same database, so a read
+   * that failed here is rarely the only thing failing.
+   */
+  if (!policy.known) return path === "/" ? null : "unknown";
+  return policy.hiddenPaths[path] ?? null;
+}
+
+/**
+ * Navigation with hidden links removed, order preserved.
+ *
+ * A hidden entry is removed with its submenu. A submenu whose entries are all
+ * hidden is removed and its parent stays an ordinary link — never an empty
+ * dropdown.
+ */
+export function filterNavigationForPolicy(
+  items: readonly NavigationItem[] | undefined,
+  policy: LinkVisibilityPolicy,
+): NavigationItem[] {
+  const out: NavigationItem[] = [];
+  for (const item of items ?? []) {
+    if (linkHideReason(item.href ?? "", policy) !== null) continue;
+    if (!item.children || item.children.length === 0) {
+      out.push(item);
+      continue;
+    }
+    const children = filterNavigationForPolicy(item.children, policy);
+    out.push(children.length > 0 ? { ...item, children } : { ...item, children: undefined });
+  }
+  return out;
+}
+
+/** A footer column as the visibility filter needs to see it. */
+type FooterColumnLike = { links: ReadonlyArray<{ href: string }> };
+
+/** Footer columns with hidden links removed; a column left with no links is dropped. */
+export function filterFooterColumnsForPolicy<C extends FooterColumnLike>(
+  columns: readonly C[] | undefined,
+  policy: LinkVisibilityPolicy,
+): C[] {
+  const out: C[] = [];
+  for (const column of columns ?? []) {
+    const links = column.links.filter((link) => linkHideReason(link.href ?? "", policy) === null);
+    if (links.length === 0 && column.links.length > 0) continue;
+    out.push(links.length === column.links.length ? column : { ...column, links });
+  }
+  return out;
+}
+
+/** A saved menu or footer link that is not shown, with the reason. */
+export type HiddenSavedLink = { label: string; href: string; reason: HiddenLinkReason };
+
+function labelText(label: unknown): string {
+  if (typeof label === "string") return label;
+  if (label && typeof label === "object") {
+    const first = Object.values(label as Record<string, unknown>).find(
+      (value) => typeof value === "string" && value.trim() !== "",
+    );
+    if (typeof first === "string") return first;
+  }
+  return "(no label)";
+}
+
+/**
+ * Every saved link in a menu (`nav`, an item list) or footer (`footer`, with
+ * `columns`) that the site is not showing right now, and why. For the editor,
+ * which explains rather than deletes: the saved item stays exactly as it is.
+ */
+export function hiddenSavedLinks(
+  section: "nav" | "footer",
+  value: unknown,
+  policy: LinkVisibilityPolicy,
+): HiddenSavedLink[] {
+  const out: HiddenSavedLink[] = [];
+  const visit = (label: unknown, href: unknown) => {
+    if (typeof href !== "string" || href.trim() === "") return;
+    const reason = linkHideReason(href, policy);
+    if (reason) out.push({ label: labelText(label), href, reason });
+  };
+  if (section === "nav") {
+    const walk = (items: unknown) => {
+      if (!Array.isArray(items)) return;
+      for (const item of items as Array<Record<string, unknown>>) {
+        visit(item?.["label"], item?.["href"]);
+        walk(item?.["children"]);
+      }
+    };
+    walk(value);
+  } else {
+    const columns = (value as { columns?: unknown } | null)?.columns;
+    if (Array.isArray(columns)) {
+      for (const column of columns as Array<{ links?: unknown }>) {
+        if (!Array.isArray(column?.links)) continue;
+        for (const link of column.links as Array<Record<string, unknown>>) {
+          visit(link?.["label"], link?.["href"]);
+        }
+      }
+    }
+  }
+  return out;
+}
+
+/** Every `href` in a menu (items with children) or a footer (`{ columns: [{ links }] }`). */
+export function savedLinkHrefs(section: "nav" | "footer", value: unknown): string[] {
+  const out: string[] = [];
+  const add = (href: unknown) => {
+    if (typeof href === "string" && href.trim() !== "") out.push(href);
+  };
+  if (section === "nav") {
+    const walk = (items: unknown) => {
+      if (!Array.isArray(items)) return;
+      for (const item of items as Array<Record<string, unknown>>) {
+        add(item?.["href"]);
+        walk(item?.["children"]);
+      }
+    };
+    walk(value);
+  } else {
+    const columns = (value as { columns?: unknown } | null)?.columns;
+    if (Array.isArray(columns)) {
+      for (const column of columns as Array<{ links?: unknown }>) {
+        if (!Array.isArray(column?.links)) continue;
+        for (const link of column.links as Array<Record<string, unknown>>) add(link?.["href"]);
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * The policy cut down to the addresses actually linked from `hrefs`.
+ *
+ * A policy sent to the browser with the page must not list every unlisted
+ * page: that would publish the address of each link-only page in the source of
+ * every other page. The chrome only needs answers for the links it has, and
+ * those addresses are already in the content that is sent anyway.
+ */
+export function restrictToLinks(
+  policy: LinkVisibilityPolicy,
+  hrefs: readonly string[],
+): LinkVisibilityPolicy {
+  const hiddenPaths: Record<string, LinkVisibilityPolicy["hiddenPaths"][string]> = {};
+  for (const href of hrefs) {
+    const path = internalPathOf(href, policy);
+    if (path !== null && policy.hiddenPaths[path]) hiddenPaths[path] = policy.hiddenPaths[path]!;
+  }
+  return { ...policy, hiddenPaths };
+}

package/src/popups/package-name.ts

@@ -0,0 +1,8 @@
+/**
+ * The separately published package the Popups module is built on.
+ *
+ * Named here, inside the module's own directory, so the module table can
+ * declare it without the rest of the CMS mentioning the popup package. This
+ * file holds only the name: importing it loads nothing from the package.
+ */
+export const POPUP_PACKAGE = "@bygghammar/lightweight-popup" as const;

package/src/popups/runtime.tsx

@@ -10,7 +10,7 @@
  * design tokens — so neither the popup package nor the site has to know about
  * the other.
  */
-import { useCallback, useEffect, useMemo, useRef } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type { ReactNode } from "react";
 import { useRouterState } from "@tanstack/react-router";
 import {
@@ -25,6 +25,8 @@ import type {
 import { ManagedForm } from "../forms/FormRenderer";
 import { onFormSubmissionSuccess } from "../forms/success-listeners";
 import { siteConfig } from "../config/site-config";
+import { containsBookingTarget, isBookingHref, stripBookingDeep } from "../cms/booking-links";
+import { useLinkVisibility } from "../site/link-visibility";
 import type { PopupPublicHost } from "./host";
 import { popupPublicHost } from "./host";
 
@@ -95,6 +97,63 @@ export function popupExcludedPaths(
 export function PopupModuleRuntime(): ReactNode {
   const path = useRouterState({ select: (state) => state.location.pathname });
   const host = popupPublicHost();
+  /*
+   * The runtime keeps the popups it was handed until its `configs` adapter
+   * changes, and keeps everything else — the popup on screen, the form in it,
+   * the visitor's counts, its timers and its analytics queue. It is never
+   * remounted, which would throw away a newsletter form a visitor is typing in.
+   *
+   * What it is handed is decided here, in render, from what this module last
+   * had from the site's repository and the policy now. So a change of policy
+   * restricts what the runtime holds at once: before the refresh it also
+   * starts has answered, and whatever becomes of it — a slow or failed read
+   * changes nothing that booking-off takes away. A read only ever brings what
+   * it found through the same rules, and only the latest read counts, so one
+   * begun under the old policy cannot bring booking back. Without a policy
+   * provider booking is visible and nothing changes.
+   */
+  const bookingVisible = useLinkVisibility().bookingVisible;
+  const [loaded, setLoaded] = useState<readonly PopupConfig[] | null>(null);
+  const offered = useRef<Offered>(NOTHING_OFFERED);
+  const offer = useMemo(
+    () => popupsToOffer(loaded ?? [], offered.current, bookingVisible),
+    // `offered` is what the runtime was last handed, read for identity only.
+    [loaded, bookingVisible],
+  );
+  useEffect(() => {
+    offered.current = offer;
+  }, [offer]);
+
+  // The repository is asked again when the host or the policy changes — and
+  // only once the runtime asks for its popups, so never where it does not run.
+  const askedFor = useRef<{ configs: PopupPublicHost["configs"]; bookingVisible: boolean } | null>(null);
+  const latestRead = useRef(0);
+  const configs = useMemo<RuntimeAdapters["configs"]>(
+    () => ({
+      listActive: async () => {
+        const asked = askedFor.current;
+        if (asked === null || asked.configs !== host.configs || asked.bookingVisible !== bookingVisible) {
+          askedFor.current = { configs: host.configs, bookingVisible };
+          const read = ++latestRead.current;
+          Promise.resolve()
+            .then(() => host.configs.listActive())
+            .then(
+              (answer) => {
+                if (read !== latestRead.current) return;
+                setLoaded((previous) =>
+                  previous !== null && JSON.stringify(previous) === JSON.stringify(answer) ? previous : answer,
+                );
+              },
+              // A failed read changes nothing: what the runtime holds already
+              // follows the policy, and stays as it is until a read succeeds.
+              () => undefined,
+            );
+        }
+        return offer.list;
+      },
+    }),
+    [host.configs, bookingVisible, offer],
+  );
 
   // The argument type comes from the port, not a copy of it: a package that
   // stopped supplying `popupKey` would fail to compile here rather than
@@ -105,14 +164,15 @@ export function PopupModuleRuntime(): ReactNode {
     ),
     [],
   );
+  const forms = useMemo(() => ({ renderForm }), [renderForm]);
 
   const adapters = useMemo<RuntimeAdapters>(
     () => ({
-      configs: host.configs,
+      configs,
       analytics: host.analytics,
-      forms: { renderForm },
+      forms,
     }),
-    [host, renderForm],
+    [configs, host, forms],
   );
 
   return (
@@ -124,5 +184,96 @@ export function PopupModuleRuntime(): ReactNode {
   );
 }
 
+type PopupConfig = Awaited<ReturnType<RuntimeAdapters["configs"]["listActive"]>>[number];
+type ContentBlock = PopupConfig["steps"][number]["blocks"][number];
+type PopupButton = Extract<ContentBlock, { type: "buttons" }>["buttons"][number];
+type BlockAction = PopupButton["action"];
+
+/** The list last handed to the runtime, and each popup's content, by key. */
+type Offered = { list: readonly PopupConfig[]; content: ReadonlyMap<string, string> };
+const NOTHING_OFFERED: Offered = { list: [], content: new Map() };
+
+/**
+ * What the runtime is handed from a load, given what it already holds.
+ *
+ * - While booking is hidden, a popup that leads to booking is not offered: it
+ *   is handed over retired (see {@link retire}).
+ * - A popup the runtime already holds is never dropped, even when the load no
+ *   longer has it (a server that withholds booking popups, a popup paused or
+ *   deleted since). The runtime tracks the open popup by key, so dropping the
+ *   open one would leave it unclosable and stop every other popup for the
+ *   rest of the visit. It stays, retired.
+ * - A popup whose content has not changed is handed over as the very object
+ *   the runtime already has. The popup on screen then re-renders nothing:
+ *   its focus trap is not re-installed (that would pull focus out of the
+ *   field being typed in), and a list with nothing new is the same list, so
+ *   the runtime's schedule is not even restarted.
+ */
+function popupsToOffer(
+  loaded: readonly PopupConfig[],
+  previous: Offered,
+  bookingVisible: boolean,
+): Offered {
+  const held = new Map(previous.list.map((popup) => [popup.key, popup]));
+  const content = new Map<string, string>();
+  const list: PopupConfig[] = [];
+  const offer = (popup: PopupConfig) => {
+    const text = JSON.stringify(popup);
+    const same = held.get(popup.key);
+    content.set(popup.key, text);
+    list.push(same !== undefined && previous.content.get(popup.key) === text ? same : popup);
+  };
+  for (const popup of loaded) {
+    offer(bookingVisible || !containsBookingTarget(popup) ? popup : retire(popup, true));
+  }
+  for (const popup of previous.list) {
+    if (!content.has(popup.key)) offer(retire(popup, !bookingVisible));
+  }
+  const unchanged =
+    list.length === previous.list.length && list.every((popup, index) => popup === previous.list[index]);
+  return { list: unchanged ? previous.list : list, content };
+}
+
+/**
+ * A popup the runtime keeps but never offers again.
+ *
+ * Paused, which the runtime neither shows nor reports as suppressed. With
+ * `hideBooking`, everything in it that leads to booking is taken out too —
+ * links, buttons, an answer or a form that would open the booking site now
+ * simply closes — so if it is the one on screen, the visitor keeps what they
+ * were reading, cannot reach booking from it, and closes it the usual way.
+ * The stored popup is not touched; this is the copy the visitor sees.
+ */
+function retire(popup: PopupConfig, hideBooking: boolean): PopupConfig {
+  const paused: PopupConfig = { ...popup, status: "paused" };
+  if (!hideBooking) return paused;
+  return stripBookingDeep({
+    ...paused,
+    steps: paused.steps.map((step) => ({ ...step, blocks: step.blocks.flatMap(withoutBookingTargets) })),
+  });
+}
+
+function withoutBookingTargets(block: ContentBlock): ContentBlock[] {
+  switch (block.type) {
+    case "link":
+      return isBookingHref(block.href) ? [] : [block];
+    case "buttons": {
+      const buttons = block.buttons.filter((button) => !opensBooking(button.action));
+      return buttons.length === 0 ? [] : [{ ...block, buttons }];
+    }
+    case "choice":
+      return [{ ...block, yes: closingInstead(block.yes), no: closingInstead(block.no) }];
+    case "form":
+      return [opensBooking(block.onSuccess) ? { ...block, onSuccess: { kind: "close" } } : block];
+    default:
+      return [block];
+  }
+}
+
+const opensBooking = (action: BlockAction) => action.kind === "openUrl" && isBookingHref(action.href);
+
+const closingInstead = (button: PopupButton): PopupButton =>
+  opensBooking(button.action) ? { ...button, action: { kind: "close" } } : button;
+
 // Default export so the module host can load this file lazily.
 export default PopupModuleRuntime;