@bygghammar/cms-platform 0.94.0 → 0.95.0

package/src/backoffice/media/ConfirmDialog.tsx

@@ -13,6 +13,7 @@ export function ConfirmDialog({
   title,
   description,
   details,
+  consequences,
   confirmLabel = "Confirm",
   cancelLabel = "Cancel",
   danger = false,
@@ -23,7 +24,13 @@ export function ConfirmDialog({
 }: {
   title: string;
   description?: string;
+  /** Short items (names, paths), one line each; long ones are truncated with a tooltip. */
   details?: string[];
+  /**
+   * What confirming will do, in full sentences. Never truncated, and read out
+   * with the description, because a warning cut off at "…" is not a warning.
+   */
+  consequences?: string[];
   confirmLabel?: string;
   cancelLabel?: string;
   danger?: boolean;
@@ -82,7 +89,11 @@ export function ConfirmDialog({
         role="dialog"
         aria-modal="true"
         aria-labelledby={`${id}-title`}
-        aria-describedby={description ? `${id}-description` : undefined}
+        aria-describedby={
+          [description ? `${id}-description` : "", consequences?.length ? `${id}-consequences` : ""]
+            .filter(Boolean)
+            .join(" ") || undefined
+        }
         className="w-full max-w-md border border-ink/15 bg-white"
         onClick={(e) => e.stopPropagation()}
       >
@@ -98,6 +109,13 @@ export function ConfirmDialog({
             </p>
           ) : null}
           {children}
+          {consequences?.length ? (
+            <ul id={`${id}-consequences`} className="list-disc space-y-1.5 pl-5 text-sm text-ink/80">
+              {consequences.map((line) => (
+                <li key={line}>{line}</li>
+              ))}
+            </ul>
+          ) : null}
           {details?.length ? (
             <ul className="max-h-40 space-y-1 overflow-auto border border-ink/10 bg-ice/30 p-2 text-[0.72rem] text-ink/70">
               {details.map((d) => (

package/src/backoffice/routes/host.ts

@@ -10,6 +10,7 @@ import type { ReactNode } from "react";
 
 import type { SiteConfig } from "../../config/site-config";
 import type { SecretsLocation } from "../../server/provider-secrets";
+import type { LinkVisibilityPolicy } from "../../navigation/visibility";
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /** Media field component as the reviews editor consumes it. */
@@ -233,6 +234,11 @@ export type BackofficeHost = {
        */
       setPageStatus?: HostServerFn;
       duplicatePage?: HostServerFn;
+      /**
+       * Optional: make a page link-only or list it again (listing only, never a
+       * publish). Without it neither screen offers the action.
+       */
+      setPageListing?: HostServerFn;
       /**
        * The site's pages, listed.
        *
@@ -303,6 +309,24 @@ export type BackofficeHost = {
     translateTarget?: string;
     translate?: HostServerFn;
   };
+  /**
+   * Site settings → Booking: the site-wide switch for booking links and the
+   * pages that keep theirs while it is off. Optional: without it the card is
+   * not shown.
+   */
+  booking?: {
+    fns: {
+      getBookingSettings: HostServerFn;
+      setBookingEnabled: HostServerFn;
+      setBookingException: HostServerFn;
+    };
+  };
+  /**
+   * The public link policy as the site currently applies it, so the navigation
+   * editor can say why a saved item is not shown. A hook, so a site can read it
+   * however it serves it. Optional: without it the editor explains nothing.
+   */
+  useLinkVisibility?: () => LinkVisibilityPolicy | undefined;
   /** Browser auth adapters used by the password-reset screen. */
   authAdapters?: {
     /** Subscribes to the recovery session; returns an unsubscribe function. */

package/src/backoffice/routes/index.tsx

@@ -37,6 +37,7 @@ import { BackupView } from "../BackupView";
 import { DomainsView } from "../DomainsView";
 import { EmailSettingsView } from "../EmailSettingsView";
 import { NavigationView } from "../NavigationView";
+import { BookingSettingsCard, type BookingSettingsData } from "../BookingSettingsCard";
 import { ReviewsView, type ReviewsSection } from "../ReviewsView";
 import { ContactDetailsView } from "../ContactDetailsView";
 import { EmailLogsView } from "../EmailLogsView";
@@ -224,6 +225,53 @@ export function VersionRoute() {
   );
 }
 
+/** Stand-in for unregistered optional functions; the queries using it stay disabled. */
+const notRegistered = async () => {
+  throw new Error("This site has not registered that backoffice function.");
+};
+
+/** Site settings → Booking, when the host registered the booking functions. */
+function BookingSettingsSection() {
+  const host = backofficeHost();
+  const booking = host.booking;
+  const qc = useQueryClient();
+  const load = useServerFn(booking?.fns.getBookingSettings ?? notRegistered);
+  const setEnabled = useServerFn(booking?.fns.setBookingEnabled ?? notRegistered);
+  const setException = useServerFn(booking?.fns.setBookingException ?? notRegistered);
+  const listPages = useServerFn(host.pages?.fns.listPages ?? notRegistered);
+  const q = useQuery({
+    queryKey: ["admin", "booking-settings"],
+    queryFn: () => load(),
+    enabled: Boolean(booking),
+  });
+  const pagesQ = useQuery({
+    queryKey: ["cms", "pages-list"],
+    queryFn: () => listPages(),
+    enabled: Boolean(booking && host.pages?.fns.listPages),
+  });
+  const resolveUrl = host.pages?.usePageUrl?.();
+  if (!booking) return null;
+  return (
+    <BookingSettingsCard
+      deps={{
+        settings: q.data as BookingSettingsData | undefined,
+        error: (q.error as Error | null) ?? null,
+        pages: (pagesQ.data as Array<{ id: string; key: string; name: string }> | undefined)?.map(
+          (page) => ({ id: page.id, key: page.key, name: page.name }),
+        ),
+        pathFor: (key) =>
+          resolveUrl ? resolveUrl(key, host.siteConfig.defaultLocale).path : `/${key}`,
+        setEnabled: (input) => setEnabled({ data: input } as never),
+        setException: (input) => setException({ data: input } as never),
+        refresh: () => {
+          void q.refetch();
+          void qc.invalidateQueries({ queryKey: ["admin", "link-visibility"] });
+        },
+      }}
+    />
+  );
+}
+
 /** Site settings screen (code defaults plus database overrides). */
 export function SiteSettingsRoute() {
   const host = backofficeHost();
@@ -259,6 +307,7 @@ export function SiteSettingsRoute() {
           window.location.href = contactPath;
         },
         MediaField: host.components.MediaField,
+        bookingSection: <BookingSettingsSection />,
       }}
     />
   );
@@ -715,10 +764,12 @@ export function NavigationRoute() {
     queryFn: () => loadSettings(),
   });
   const settingOverrides = (settingsQ.data?.overrides ?? {}) as SiteSettingOverrides;
+  const linkPolicy = (host.useLinkVisibility ?? noLinkVisibility)();
 
   return (
     <NavigationView
       deps={{
+        linkPolicy,
         overrides,
         site,
         defaults: host.content.defaults,
@@ -749,6 +800,9 @@ export function NavigationRoute() {
  */
 const noEffectiveAdminHost = async () => null;
 
+/** A host without a link policy: the navigation editor explains nothing. */
+const noLinkVisibility = () => undefined;
+
 /** Per-locale domain mapping. */
 function DomainsRouteInner() {
   const host = backofficeHost();

package/src/backoffice/routes/pages.tsx

@@ -21,6 +21,11 @@ import { useResolvedSiteConfig } from "../shell/use-resolved-config";
 import { ResetPasswordView } from "../ResetPasswordView";
 import { backofficeHost, backofficePaths, requireHostGroup } from "./host";
 
+/** Stand-in for unregistered optional functions; never called (the action is not offered). */
+const notRegistered = async () => {
+  throw new Error("This site has not registered that page function.");
+};
+
 const notify = {
   success: (m: string) => toast.success(m),
   error: (m: string) => toast.error(m),
@@ -47,6 +52,8 @@ export function PageBuilderRoute() {
   const listPubs = useServerFn(pages.fns.listPagePublications);
   const cancelPub = useServerFn(pages.fns.cancelPagePublication);
   const rename = useServerFn(pages.fns.renamePage);
+  const setStatus = useServerFn(pages.fns.setPageStatus ?? notRegistered);
+  const setListing = useServerFn(pages.fns.setPageListing ?? notRegistered);
 
   const pageQ = useQuery({
     queryKey: ["cms", "page-edit", key],
@@ -127,6 +134,12 @@ export function PageBuilderRoute() {
         restoreVersion: (versionId, editSessionId) =>
           restore({ data: { versionId, editSessionId } }),
         rename: (input) => rename({ data: input }),
+        setPageStatus: pages.fns.setPageStatus
+          ? (input) => setStatus({ data: input } as never)
+          : undefined,
+        setPageListing: pages.fns.setPageListing
+          ? (input) => setListing({ data: input } as never)
+          : undefined,
         refetchPage: () => void pageQ.refetch(),
         refetchVersions: () => void versionsQ.refetch(),
         refetchPublications: () => void pubsQ.refetch(),

package/src/cms/booking-links.ts

@@ -0,0 +1,176 @@
+/**
+ * Booking links: which addresses count as one, and how they are taken out of
+ * public content while a site has booking switched off.
+ *
+ * A booking link is an `https:` address whose host starts with `booking` —
+ * `https://booking.voyara.se/…`, `https://booking.example.com`. That is the
+ * whole rule. The address is read the way a browser reads it (character
+ * references decoded, tabs and line breaks dropped, the ends trimmed, a
+ * protocol-relative `//booking…` taken as `https:`), and only the scheme and
+ * host decide. A link to another site whose query string happens to contain a
+ * booking address is not a booking link, and neither is plain text that
+ * mentions one.
+ *
+ * Removal is applied to a copy of the content on its way out of the server,
+ * never to what is stored: switching booking back on restores every link
+ * exactly as it was written.
+ */
+import { decodeAttr, sanitizeHtml } from "../html/sanitize-html";
+
+/** A browser drops these anywhere inside a URL before parsing it. */
+const DROPPED_INSIDE = /[\t\n\r]/g;
+/** And trims C0 controls and spaces from both ends. */
+const TRIMMED_ENDS = /^[\u0000- ]+|[\u0000- ]+$/g;
+
+/** True when `raw` is an address that leads to a booking site. */
+export function isBookingHref(raw: unknown): boolean {
+  if (typeof raw !== "string" || raw === "") return false;
+  let value = decodeAttr(raw).replace(DROPPED_INSIDE, "").replace(TRIMMED_ENDS, "");
+  if (!value) return false;
+  if (value.startsWith("//")) value = `https:${value}`;
+  let url: URL;
+  try {
+    // No base: a relative address ("/boka", "boka") is never a booking site.
+    url = new URL(value);
+  } catch {
+    return false;
+  }
+  return url.protocol === "https:" && url.hostname.startsWith("booking");
+}
+
+/** Every tag, as the sanitizer reads them (quoted `>` included). */
+const TAG = /<\s*(\/)?\s*([a-zA-Z][a-zA-Z0-9-]*)((?:[^>"']|"[^"]*"|'[^']*')*)>/g;
+const HREF = /(?:^|\s)href\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+))/i;
+
+/** Placeholder for a removed link while emptied containers are collapsed. */
+const REMOVED = "\u0000booking-link\u0000";
+
+/**
+ * Containers that existed only to hold a removed link and are dropped with it:
+ * a paragraph, list item or heading that contained the "Boka" button and
+ * nothing else would otherwise leave an empty line behind.
+ */
+const COLLAPSIBLE =
+  "p|li|ul|ol|div|span|strong|b|em|i|u|s|small|mark|h1|h2|h3|h4|h5|h6|figure|figcaption|blockquote";
+const FILLER = `(?:\\s|&nbsp;|\\u00a0|<br\\s*\\/?>|${REMOVED})`;
+const EMPTIED = new RegExp(
+  `<(${COLLAPSIBLE})(?:\\s[^>]*)?>${FILLER}*${REMOVED}${FILLER}*<\\/\\1>`,
+  "gi",
+);
+
+function anchorLeadsToBooking(attributes: string): boolean {
+  const match = HREF.exec(attributes);
+  if (!match) return false;
+  return isBookingHref(match[1] ?? match[2] ?? match[3] ?? "");
+}
+
+/**
+ * The same HTML with every booking link removed, link text included.
+ *
+ * Everything else — the prose around the link, other links, images, styling —
+ * is left exactly as it was. Input with no booking link comes back unchanged
+ * (the same string); input with one comes back sanitized, which is what every
+ * renderer does to it anyway.
+ */
+export function stripBookingFromHtml(html: string): string {
+  if (!/<\s*a\b/i.test(html)) return html;
+  const clean = sanitizeHtml(html);
+  let out = "";
+  let last = 0;
+  let depth = 0;
+  let removed = false;
+  TAG.lastIndex = 0;
+  let match: RegExpExecArray | null;
+  while ((match = TAG.exec(clean))) {
+    const closing = Boolean(match[1]);
+    const tag = match[2]!.toLowerCase();
+    if (depth > 0) {
+      if (tag === "a") depth += closing ? -1 : 1;
+      if (depth === 0) {
+        out += REMOVED;
+        last = match.index + match[0].length;
+      }
+      continue;
+    }
+    if (!closing && tag === "a" && anchorLeadsToBooking(match[3] ?? "")) {
+      out += clean.slice(last, match.index);
+      depth = 1;
+      removed = true;
+    }
+  }
+  if (!removed) return html;
+  out += depth > 0 ? REMOVED : clean.slice(last);
+  let previous: string;
+  do {
+    previous = out;
+    out = out.replace(EMPTIED, REMOVED);
+  } while (out !== previous);
+  return out.split(REMOVED).join("");
+}
+
+/**
+ * A copy of any JSON-shaped value with booking links taken out.
+ *
+ * A string that *is* a booking address becomes empty — every block treats an
+ * empty link as "no button", so a hero keeps its picture and heading and loses
+ * only the button — and booking links inside HTML strings are removed with
+ * {@link stripBookingFromHtml}. Objects and arrays are rebuilt only where
+ * something changed, so untouched content keeps its identity.
+ */
+export function stripBookingDeep<T>(value: T): T {
+  return strip(value) as T;
+}
+
+function strip(value: unknown): unknown {
+  if (typeof value === "string") {
+    if (isBookingHref(value)) return "";
+    return value.includes("<") ? stripBookingFromHtml(value) : value;
+  }
+  if (Array.isArray(value)) {
+    let changed = false;
+    const next = value.map((item) => {
+      const out = strip(item);
+      if (out !== item) changed = true;
+      return out;
+    });
+    return changed ? next : value;
+  }
+  if (value !== null && typeof value === "object") {
+    let changed = false;
+    const next: Record<string, unknown> = {};
+    for (const [key, item] of Object.entries(value as Record<string, unknown>)) {
+      const out = strip(item);
+      if (out !== item) changed = true;
+      next[key] = out;
+    }
+    return changed ? next : value;
+  }
+  return value;
+}
+
+/** True when any string anywhere inside `value` leads to a booking site. */
+export function containsBookingTarget(value: unknown): boolean {
+  if (typeof value === "string") {
+    if (isBookingHref(value)) return true;
+    return value.includes("<") && stripBookingFromHtml(value) !== value;
+  }
+  if (Array.isArray(value)) return value.some(containsBookingTarget);
+  if (value !== null && typeof value === "object") {
+    return Object.values(value as Record<string, unknown>).some(containsBookingTarget);
+  }
+  return false;
+}
+
+/**
+ * Popups to show while booking is off: every popup that links to a booking
+ * site is withheld whole.
+ *
+ * A popup is one short message with one purpose. Taking only the button out of
+ * one that says "Book your cabin now" leaves a promise with no way to act on
+ * it, and an answer or a form that ends by opening the booking site cannot be
+ * removed without changing what the popup does — so the popup is simply not
+ * offered until booking is back.
+ */
+export function withoutBookingPopups<T>(configs: readonly T[]): T[] {
+  return configs.filter((config) => !containsBookingTarget(config));
+}

package/src/cms/page-publication.ts

@@ -155,21 +155,26 @@ export function isPubliclyVisible(state: PublicationState): boolean {
   return state === "published" || state === "ending";
 }
 
+/*
+ * "Offline" rather than "Hidden": a page can also be link-only — online, but
+ * left out of menus and the sitemap — and two different states must not share
+ * the word "hidden".
+ */
 export const PUBLICATION_STATE_LABELS: Record<PublicationState, string> = {
-  draft: "Hidden",
+  draft: "Offline",
   scheduled: "Scheduled to publish",
   published: "Published",
-  ending: "Scheduled to hide",
-  expired: "Hidden after expiry",
+  ending: "Scheduled to go offline",
+  expired: "Offline after expiry",
 };
 
 /** Longer wording for tooltips and screen-reader descriptions. */
 export const PUBLICATION_STATE_DESCRIPTIONS: Record<PublicationState, string> = {
-  draft: "Not visible on the public website. Staff can still edit and preview it.",
+  draft: "Not on the public website; visitors get “page not found”. Staff can still edit and preview it.",
   scheduled: "Not visible yet. It appears by itself when its publication window opens.",
   published: "Visible on the public website right now.",
-  ending: "Visible now, and scheduled to disappear when its window closes.",
-  expired: "Not visible any more — its publication window has closed.",
+  ending: "Visible now, and scheduled to go offline when its window closes.",
+  expired: "Offline — its publication window has closed.",
 };
 
 /**

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/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) => {