@bygghammar/cms-platform 0.94.0 → 0.96.0

package/src/backoffice/SiteSettingsView.tsx

@@ -47,6 +47,8 @@ export type SiteSettingsDeps = {
    */
   /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
   MediaField?: (props: any) => ReactNode;
+  /** Site settings → Booking, rendered after Modules when the host supports it. */
+  bookingSection?: ReactNode;
 };
 
 // Labels and order come from the module table, so a new module appears here
@@ -290,6 +292,8 @@ export function SiteSettingsView({ deps }: { deps: SiteSettingsDeps }) {
         </div>
       </section>
 
+      {deps.bookingSection ?? null}
+
       {Object.keys(brand).length > 0 && (
         <section className={`mt-6 ${cardClass}`}>
           <SectionHeader

package/src/backoffice/StatusBadge.tsx

@@ -15,26 +15,30 @@
  */
 
 import type { ReactNode } from "react";
-import { CalendarClock, CircleDot, CircleSlash, Eye, EyeOff, FileEdit } from "lucide-react";
+import { CalendarClock, CircleDot, CircleSlash, Eye, EyeOff, FileEdit, Link2, Lock } from "lucide-react";
 import { PAGE_STATUS_DESCRIPTIONS, PAGE_STATUS_LABELS, type PageStatus } from "../cms/page-status";
 import {
   publicationSummary,
   type PublicationState,
   type PublicationTransitionKind,
 } from "../cms/page-publication";
+import { PAGE_VISIBILITY_DESCRIPTIONS, PROTECTED_PAGE_REASON, type PageListing } from "../cms/page-visibility";
+import { isPubliclyVisible } from "../cms/page-publication";
 import {
   VISIBILITY_STATE_DESCRIPTIONS,
   VISIBILITY_STATE_LABELS,
   type VisibilityState,
 } from "../cms/visibility-schedule";
 
-export type StatusTone = "draft" | "live" | "hidden" | "scheduled";
+export type StatusTone = "draft" | "live" | "hidden" | "scheduled" | "unlisted" | "protected";
 
 const TONE_CLASS: Record<StatusTone, string> = {
   draft: "border-ink/25 bg-ink/[0.04] text-ink/70",
   live: "border-sea/40 bg-ice/60 text-ink",
   hidden: "border-ink/20 bg-ink/[0.02] text-ink/50",
   scheduled: "border-brass/50 bg-brass/10 text-ink/80",
+  unlisted: "border-ink/40 bg-paper text-ink",
+  protected: "border-ink/15 bg-ink/[0.02] text-ink/60",
 };
 
 const TONE_ICON: Record<StatusTone, (props: { className?: string }) => ReactNode> = {
@@ -42,6 +46,8 @@ const TONE_ICON: Record<StatusTone, (props: { className?: string }) => ReactNode
   live: CircleDot,
   hidden: CircleSlash,
   scheduled: CalendarClock,
+  unlisted: Link2,
+  protected: Lock,
 };
 
 const PUBLICATION_TONE: Record<PublicationState, StatusTone> = {
@@ -172,3 +178,33 @@ export function VisibilityIcon({ visible }: { visible: boolean }) {
     <EyeOff className="size-4" aria-hidden="true" />
   );
 }
+
+/**
+ * `LINK ONLY` beside the publication badge when a page is unlisted.
+ *
+ * Nothing is shown for an ordinary listed page — that is the default and the
+ * publication badge already says everything. An offline page that is link-only
+ * says so in its own words, because publishing it will not list it.
+ */
+export function ListingBadge({
+  listing,
+  publication,
+}: {
+  listing: PageListing;
+  publication: PublicationState;
+}) {
+  if (listing !== "link-only") return null;
+  const live = isPubliclyVisible(publication);
+  return (
+    <StatusBadge
+      label={live ? "Link only" : "Link only once published"}
+      tone="unlisted"
+      title={PAGE_VISIBILITY_DESCRIPTIONS["link-only"]}
+    />
+  );
+}
+
+/** Marks the start and contact pages, which cannot be unpublished or unlisted. */
+export function ProtectedBadge() {
+  return <StatusBadge label="Protected" tone="protected" title={PROTECTED_PAGE_REASON} />;
+}

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.",
 };
 
 /**