@bygghammar/cms-platform 0.47.0 → 0.49.0

package/src/site/routes.ts

@@ -0,0 +1,350 @@
+/**
+ * Localized routing + SEO engine (site-agnostic).
+ *
+ * A site owns only its page registry: a `pageKey -> { slug, seo }` map.
+ * Everything derived from it — path building, canonical URLs, hreflang
+ * alternates, the head payload and sitemap entries — is generic and lives
+ * here, so every site gets identical SEO behaviour and identical fixes.
+ *
+ * Usage in a site:
+ *
+ *   export const PAGES: Record<string, PageDef> = { ... };
+ *   export const {
+ *     resolveRoute, resolveAbsolute, pageHeadMeta,
+ *     sitemapEntries, sitemapIndexEntries, publishedLocales,
+ *   } = createSiteRoutes(PAGES);
+ */
+
+import { DEFAULT_LOCALE, SUPPORTED_LOCALES, type Locale } from "../i18n/locales";
+import type { Localized, LocalizedImage, LocalizedString } from "../i18n/types";
+import { t, tv } from "../i18n/resolve";
+
+export type SeoMeta = {
+  title: LocalizedString;
+  description: LocalizedString;
+  ogTitle?: LocalizedString;
+  ogDescription?: LocalizedString;
+  ogImage?: LocalizedImage;
+  ogType?: "website" | "article" | "product";
+  twitterCard?: "summary" | "summary_large_image";
+  keywords?: LocalizedString;
+  robots?: string;
+  jsonLd?: Localized<Record<string, unknown>>;
+};
+
+export type PageDef = {
+  key: string;
+  slug: Localized<string>;
+  seo: SeoMeta;
+};
+
+/**
+ * A CMS override for a single page. All fields are partial —
+ * anything omitted falls back to the static registry entry.
+ */
+export type PageSeoOverride = {
+  slugs?: Localized<string>;
+  seo?: Partial<SeoMeta>;
+};
+
+/** Map keyed by `pageKey`; a missing key means "use registry defaults". */
+export type PageSeoOverrides = Record<string, PageSeoOverride>;
+
+export type PageKey = string;
+
+/** Minimal shape of a locale→domain mapping row. */
+export type RouteLocaleDomain = { locale: string; domain: string; isDefault?: boolean };
+
+/** Locales in which the default locale gets NO URL prefix. */
+export const PREFIX_STRATEGY = {
+  default: "none",
+} as const;
+
+type HeadMeta =
+  | { title: string }
+  | { name: string; content: string }
+  | { property: string; content: string };
+
+type HeadLink = { rel: string; href: string; hrefLang?: string; type?: string };
+
+type HeadScript = {
+  type: "application/ld+json";
+  children: string;
+};
+
+export type PageHead = {
+  meta: HeadMeta[];
+  links: HeadLink[];
+  scripts?: HeadScript[];
+};
+
+export type SitemapEntry = {
+  pageKey: PageKey;
+  locale: Locale;
+  url: string;
+  alternates: Array<{ locale: Locale | "x-default"; url: string }>;
+};
+
+function localePrefix(locale: Locale): string {
+  return locale === DEFAULT_LOCALE ? "" : `/${locale}`;
+}
+
+/**
+ * Merge a static page definition with an optional CMS override.
+ * Returns a new PageDef; the original inputs are not mutated.
+ */
+export function mergePageDef(def: PageDef, override?: PageSeoOverride): PageDef {
+  if (!override) return def;
+  return {
+    key: def.key,
+    slug: { ...def.slug, ...(override.slugs ?? {}) },
+    seo: { ...def.seo, ...(override.seo ?? {}) },
+  };
+}
+
+/**
+ * Pages created in the page builder have no static registry entry. They are
+ * still routable (`/<key>`) and fully editable through `page_seo`, so build a
+ * neutral definition for them and let the CMS override supply the real values.
+ */
+export function fallbackPageDef(pageKey: string): PageDef {
+  const slug: Localized<string> = {};
+  const title: Localized<string> = {};
+  const description: Localized<string> = {};
+  const pretty = pageKey.replace(/[-_]+/g, " ").replace(/^\s*\w/, (c) => c.toUpperCase());
+  for (const l of SUPPORTED_LOCALES) {
+    slug[l] = pageKey;
+    title[l] = pretty;
+    description[l] = "";
+  }
+  return {
+    key: pageKey,
+    slug: slug as Localized<string>,
+    seo: { title: title as LocalizedString, description: description as LocalizedString },
+  };
+}
+
+function originForLocale(locale: Locale, domains: RouteLocaleDomain[]): string {
+  const match = domains.find((d) => d.locale === locale);
+  if (!match) return "";
+  const domain = match.domain.replace(/^https?:\/\//, "").replace(/\/+$/, "");
+  return `https://${domain}`;
+}
+
+/**
+ * Build the sitemap index entries — one sitemap URL per configured domain.
+ * Independent of any page registry.
+ */
+export function sitemapIndexEntries(domains: RouteLocaleDomain[] = []): Array<{
+  locale: Locale;
+  url: string;
+}> {
+  return domains.map((d) => {
+    const domain = d.domain.replace(/^https?:\/\//, "").replace(/\/+$/, "");
+    return {
+      locale: d.locale as Locale,
+      url: `https://${domain}/sitemap/${d.locale}.xml`,
+    };
+  });
+}
+
+export type SiteRoutes = {
+  PAGES: Record<string, PageDef>;
+  mergePageDef: typeof mergePageDef;
+  fallbackPageDef: typeof fallbackPageDef;
+  resolveRoute: (pageKey: PageKey, locale?: Locale, overrides?: PageSeoOverrides) => string;
+  resolveAbsolute: (
+    pageKey: PageKey,
+    locale?: Locale,
+    origin?: string,
+    overrides?: PageSeoOverrides,
+  ) => string;
+  publishedLocales: (pageKey: PageKey, overrides?: PageSeoOverrides) => Locale[];
+  pageHeadMeta: (
+    pageKey: PageKey,
+    locale?: Locale,
+    origin?: string,
+    overrides?: PageSeoOverrides,
+    domains?: RouteLocaleDomain[],
+  ) => PageHead;
+  sitemapEntries: (
+    locale: Locale,
+    domains?: RouteLocaleDomain[],
+    overrides?: PageSeoOverrides,
+  ) => SitemapEntry[];
+  sitemapIndexEntries: typeof sitemapIndexEntries;
+};
+
+/** Build the routing/SEO engine for one site's page registry. */
+export function createSiteRoutes(PAGES: Record<string, PageDef>): SiteRoutes {
+  function getDef(pageKey: PageKey, overrides?: PageSeoOverrides): PageDef {
+    const base = PAGES[pageKey] ?? fallbackPageDef(pageKey);
+    return mergePageDef(base, overrides?.[pageKey]);
+  }
+
+  function slugFor(page: PageDef, locale: Locale): string | undefined {
+    return tv(page.slug, locale);
+  }
+
+  function pathFromDef(page: PageDef, locale: Locale): string {
+    const slug = slugFor(page, locale) ?? slugFor(page, DEFAULT_LOCALE) ?? "";
+    const prefix = localePrefix(locale);
+    const path = slug ? `/${slug}` : "";
+    const full = `${prefix}${path}`;
+    return full === "" ? "/" : full;
+  }
+
+  function resolveRoute(
+    pageKey: PageKey,
+    locale: Locale = DEFAULT_LOCALE,
+    overrides?: PageSeoOverrides,
+  ): string {
+    return pathFromDef(getDef(pageKey, overrides), locale);
+  }
+
+  function resolveAbsolute(
+    pageKey: PageKey,
+    locale: Locale = DEFAULT_LOCALE,
+    origin: string = "",
+    overrides?: PageSeoOverrides,
+  ): string {
+    const base = origin.replace(/\/+$/, "");
+    return `${base}${resolveRoute(pageKey, locale, overrides)}`;
+  }
+
+  function publishedLocales(pageKey: PageKey, overrides?: PageSeoOverrides): Locale[] {
+    const def = getDef(pageKey, overrides);
+    return SUPPORTED_LOCALES.filter((l) => typeof def.slug[l] === "string");
+  }
+
+  function pageHeadMeta(
+    pageKey: PageKey,
+    locale: Locale = DEFAULT_LOCALE,
+    origin: string = "",
+    overrides?: PageSeoOverrides,
+    domains: RouteLocaleDomain[] = [],
+  ): PageHead {
+    const page = getDef(pageKey, overrides);
+    const seo = page.seo;
+
+    const title = t(seo.title, locale);
+    const description = t(seo.description, locale);
+    const ogTitle = t(seo.ogTitle ?? seo.title, locale);
+    const ogDescription = t(seo.ogDescription ?? seo.description, locale);
+    const ogImage = seo.ogImage;
+    const ogType = seo.ogType ?? "website";
+    const twitterCard = seo.twitterCard ?? "summary_large_image";
+    const canonical = resolveAbsolute(pageKey, locale, origin, overrides);
+    const localesForPage = SUPPORTED_LOCALES.filter((l) => typeof page.slug[l] === "string");
+
+    const meta: HeadMeta[] = [
+      { title },
+      { name: "description", content: description },
+      { property: "og:title", content: ogTitle },
+      { property: "og:description", content: ogDescription },
+      { property: "og:type", content: ogType },
+      { property: "og:url", content: canonical },
+      { property: "og:locale", content: locale },
+      { name: "twitter:card", content: twitterCard },
+      { name: "twitter:title", content: ogTitle },
+      { name: "twitter:description", content: ogDescription },
+    ];
+
+    for (const alt of localesForPage) {
+      if (alt !== locale) {
+        meta.push({ property: "og:locale:alternate", content: alt });
+      }
+    }
+
+    if (seo.keywords) {
+      const kw = t(seo.keywords, locale);
+      if (kw) meta.push({ name: "keywords", content: kw });
+    }
+    if (seo.robots) {
+      meta.push({ name: "robots", content: seo.robots });
+    }
+    if (ogImage) {
+      const src = tv(ogImage.srcByLocale, locale) ?? ogImage.src;
+      const abs = src.startsWith("http") ? src : `${origin}${src}`;
+      const alt = t(ogImage.alt, locale);
+      meta.push({ property: "og:image", content: abs });
+      if (alt) meta.push({ property: "og:image:alt", content: alt });
+      meta.push({ name: "twitter:image", content: abs });
+      if (alt) meta.push({ name: "twitter:image:alt", content: alt });
+    }
+
+    const links: HeadLink[] = [{ rel: "canonical", href: canonical }];
+    for (const alt of localesForPage) {
+      const altOrigin = originForLocale(alt, domains) || origin;
+      links.push({
+        rel: "alternate",
+        hrefLang: alt,
+        href: resolveAbsolute(pageKey, alt, altOrigin, overrides),
+      });
+    }
+    const defaultOrigin = originForLocale(DEFAULT_LOCALE, domains) || origin;
+    links.push({
+      rel: "alternate",
+      hrefLang: "x-default",
+      href: resolveAbsolute(pageKey, DEFAULT_LOCALE, defaultOrigin, overrides),
+    });
+
+    const scripts: HeadScript[] = [];
+    if (seo.jsonLd) {
+      const ld = tv(seo.jsonLd, locale);
+      if (ld) {
+        scripts.push({
+          type: "application/ld+json",
+          children: JSON.stringify(ld),
+        });
+      }
+    }
+
+    return { meta, links, scripts: scripts.length ? scripts : undefined };
+  }
+
+  function sitemapEntries(
+    locale: Locale,
+    domains: RouteLocaleDomain[] = [],
+    overrides?: PageSeoOverrides,
+  ): SitemapEntry[] {
+    const origin = originForLocale(locale, domains);
+    const out: SitemapEntry[] = [];
+    for (const key of Object.keys(PAGES) as PageKey[]) {
+      const locales = publishedLocales(key, overrides);
+      if (!locales.includes(locale)) continue;
+      const alternates: Array<{ locale: Locale | "x-default"; url: string }> = locales.map((l) => ({
+        locale: l,
+        url: resolveAbsolute(key, l, originForLocale(l, domains) || origin, overrides),
+      }));
+      alternates.push({
+        locale: "x-default",
+        url: resolveAbsolute(
+          key,
+          DEFAULT_LOCALE,
+          originForLocale(DEFAULT_LOCALE, domains) || origin,
+          overrides,
+        ),
+      });
+      out.push({
+        pageKey: key,
+        locale,
+        url: resolveAbsolute(key, locale, origin, overrides),
+        alternates,
+      });
+    }
+    return out;
+  }
+
+  return {
+    PAGES,
+    mergePageDef,
+    fallbackPageDef,
+    resolveRoute,
+    resolveAbsolute,
+    publishedLocales,
+    pageHeadMeta,
+    sitemapEntries,
+    sitemapIndexEntries,
+  };
+}