@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/site-builder/build.d.ts

@@ -0,0 +1,18 @@
+import type { BuildOptions, SiteConfig } from './types';
+/**
+ * Build a static stx site end-to-end:
+ * 1. Bundle all pages with bun-plugin-stx
+ * 2. Inject Css CSS into each HTML file
+ * 3. Replace stx default SEO tags with site-specific ones
+ * 4. Drop the empty bundle chunks bun-plugin-stx leaves behind
+ * 5. Copy public/ assets verbatim
+ * 6. Synthesize 404.html (uses pages/404.stx if present, else clones index)
+ * 7. Generate sitemap.xml and robots.txt
+ */
+export declare function buildStaticSite(options: BuildOptions): Promise<BuildResult>;
+export declare function defineSiteConfig<T extends SiteConfig>(config: T): T;
+export declare interface BuildResult {
+  outDir: string
+  pages: string[]
+  durationMs: number
+}

package/dist/site-builder/build.js

@@ -0,0 +1,252 @@
+import { Glob, default as Bun } from "../bun-shim.js";
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join, relative } from "node:path";
+import process from "node:process";
+import stxPlugin from "bun-plugin-stx";
+import { CONVENTIONAL_ASSET_OUTPUT, resolveConventionalAssetRoot } from "../asset-roots.js";
+import { externalizeSharedAssets } from "../build-externalize.js";
+import { externalizeRepeatedAssets } from "../build-externalize-repeated.js";
+import { injectCss } from "../dev-server/ts-css.js";
+import { injectSeo } from "./seo.js";
+import { generateSitemap } from "./sitemap.js";
+import { generateRobots } from "./robots.js";
+import { injectRouterScript } from "./router.js";
+import { injectThemeBootstrap } from "./theme.js";
+import { buildIsolatingFailures } from "../isolated-build.js";
+import {
+  applyTranslations,
+  buildAlternateLinks,
+  buildLangPickerScript,
+  localizePath,
+  resolveI18n,
+  stampLocaleLayoutGroup
+} from "./i18n.js";
+export async function buildStaticSite(options) {
+  const start = Date.now(), pagesDir = options.pagesDir ?? "pages", outDir = options.outDir ?? "dist", publicDir = options.publicDir ?? "public";
+  if (!options.noClean)
+    rmSync(outDir, { recursive: !0, force: !0 });
+  mkdirSync(outDir, { recursive: !0 });
+  const glob = new Glob(`${pagesDir}/**/*.stx`), discovered = await Array.fromAsync(glob.scan(".")), excludeDirs = options.excludeDirs ?? ["layouts", "partials", "components"], excluded = [], entrypoints = discovered.filter((file) => {
+    const rel = file.slice(pagesDir.length).replace(/^[\\/]+/, "");
+    if (rel.split(/[\\/]/).slice(0, -1).some((seg) => excludeDirs.includes(seg))) {
+      excluded.push(file);
+      return !1;
+    }
+    return !rel.split(/[\\/]/).some((seg) => seg.startsWith("_"));
+  });
+  if (excluded.length > 0)
+    console.warn(`[stx] ${excluded.length} file(s) under ${pagesDir}/ skipped as non-pages: ${excludeDirs.join(", ")}`);
+  if (entrypoints.length === 0)
+    throw Error(`No .stx files found in ${pagesDir}/`);
+  const isolated = await buildIsolatingFailures(entrypoints, (subset) => Bun.build({
+    entrypoints: subset,
+    outdir: outDir,
+    plugins: [stxPlugin()],
+    naming: { entry: "[name].[ext]" }
+  }));
+  if (isolated.failed.length > 0) {
+    for (const { entrypoint, error } of isolated.failed)
+      console.error(`[stx] failed to build ${entrypoint}:
+  ${error}`);
+    if (isolated.succeeded.length === 0)
+      throw Error(`Build failed: none of the ${entrypoints.length} page(s) could be built`);
+    console.error(`[stx] ${isolated.failed.length} of ${entrypoints.length} page(s) skipped; the rest were built.`);
+  }
+  pruneEmptyJsChunks(outDir);
+  const htmlFiles = listFiles(outDir).filter((f) => f.endsWith(".html")), i18n = resolveI18n(options, process.cwd()), knownPaths = new Set(htmlFiles.map(pathFromFile));
+  for (const file of htmlFiles) {
+    const fullPath = join(outDir, file), sourceHtml = readFileSync(fullPath, "utf8"), basePath = pathFromFile(file), localesToEmit = i18n ? i18n.locales : [options.seo?.locale?.split(/[_-]/)[0] ?? "en"];
+    for (const locale of localesToEmit) {
+      let html = sourceHtml;
+      html = stripDeadScriptTags(html);
+      if (i18n)
+        html = applyTranslations(html, i18n, locale);
+      html = await injectCss(html, process.cwd());
+      html = injectSeo(html, options, options.pages?.[basePath], basePath);
+      if (i18n) {
+        html = applyLocaleHead(html, options, i18n, locale, basePath);
+        html = localizeInternalLinks(html, locale, i18n.defaultLocale, knownPaths);
+        html = stampLocaleLayoutGroup(html, locale);
+      }
+      html = injectThemeBootstrap(html, options);
+      html = autoWrapContent(html);
+      if (i18n)
+        html = html.replace(/<\/body>/i, `${buildLangPickerScript(i18n, locale)}
+</body>`);
+      if (options.spa !== !1)
+        html = await injectRouterScript(html, options.router);
+      const targetFile = i18n ? localePathToFile(basePath, locale, i18n.defaultLocale) : file, targetPath = join(outDir, targetFile);
+      mkdirSync(dirnameOf(targetPath), { recursive: !0 });
+      writeFileSync(targetPath, html);
+      if (i18n && locale !== i18n.defaultLocale && targetFile !== file)
+        ;
+    }
+  }
+  const externalized = externalizeSharedAssets(outDir);
+  if (externalized.assets > 0)
+    console.log(`[stx] externalized ${externalized.assets} asset(s) from ${externalized.pages} page(s) (${(externalized.bytesInlined / 1024).toFixed(1)}KB removed from HTML)`);
+  const repeated = externalizeRepeatedAssets(outDir);
+  if (repeated.assets > 0)
+    console.log(`[stx] externalized ${repeated.assets} repeated asset(s) from ${repeated.pages} page(s) (${(repeated.bytesInlined / 1024).toFixed(1)}KB removed from HTML)`);
+  if (existsSync(publicDir))
+    cpSync(publicDir, outDir, { recursive: !0 });
+  const conventionalAssets = resolveConventionalAssetRoot();
+  if (conventionalAssets)
+    cpSync(conventionalAssets, join(outDir, CONVENTIONAL_ASSET_OUTPUT), { recursive: !0 });
+  const fourOhFourSrc = join(outDir, "404.html");
+  if (!existsSync(fourOhFourSrc) && existsSync(join(outDir, "index.html"))) {
+    const fallback = readFileSync(join(outDir, "index.html"), "utf8").replace(/<title>[^<]*<\/title>/i, `<title>404 \u2014 ${escapeText(options.name)}</title>`);
+    writeFileSync(fourOhFourSrc, fallback);
+  }
+  if (options.sitemap !== !1) {
+    const entries = [], basePaths = htmlFiles.filter((f) => f !== "404.html").map(pathFromFile), sitemapLocales = i18n ? i18n.locales : [null];
+    for (const basePath of basePaths) {
+      const meta = options.pages?.[basePath];
+      for (const loc of sitemapLocales) {
+        const path = loc && i18n ? localizePath(basePath, loc, i18n.defaultLocale) : basePath;
+        entries.push({ path, page: meta });
+      }
+    }
+    writeFileSync(join(outDir, "sitemap.xml"), generateSitemap(options, entries));
+  }
+  const robots = generateRobots(options);
+  if (robots !== null)
+    writeFileSync(join(outDir, "robots.txt"), robots);
+  const builtPages = htmlFiles.map(pathFromFile);
+  return { outDir, pages: builtPages, durationMs: Date.now() - start };
+}
+function dirnameOf(p) {
+  return dirname(p);
+}
+function localePathToFile(basePath, locale, defaultLocale) {
+  const localized = localizePath(basePath, locale, defaultLocale);
+  if (localized === "/")
+    return "index.html";
+  const trimmed = localized.replace(/^\//, "").replace(/\/$/, "");
+  if (!trimmed.includes("/")) {
+    if (locale !== defaultLocale && trimmed === locale)
+      return `${locale}/index.html`;
+    return `${trimmed}.html`;
+  }
+  return `${trimmed}.html`.replace(/\.html\.html$/, ".html");
+}
+function pathFromFile(file) {
+  if (file === "index.html")
+    return "/";
+  return `/${file.replace(/\.html$/, "").replace(/\/index$/, "")}`;
+}
+function listFiles(dir, base = dir) {
+  const out = [];
+  if (!existsSync(dir))
+    return out;
+  for (const entry of readdirSync(dir, { withFileTypes: !0 })) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory())
+      out.push(...listFiles(full, base));
+    else
+      out.push(relative(base, full));
+  }
+  return out;
+}
+function pruneEmptyJsChunks(outDir) {
+  for (const file of listFiles(outDir)) {
+    if (!/^chunk-.*\.js(?:\.map)?$/.test(file))
+      continue;
+    const full = join(outDir, file);
+    try {
+      if (statSync(full).size === 0)
+        unlinkSync(full);
+    } catch {}
+  }
+}
+function stripDeadScriptTags(html) {
+  return html.replace(/<script[^>]*src=["']\.\/chunk-[^"']*\.js["'][^>]*><\/script>\s*/g, "");
+}
+function applyLocaleHead(html, site, i18n, locale, basePath) {
+  if (!i18n)
+    return html;
+  if (/<html\b[^>]*\blang=/i.test(html))
+    html = html.replace(/<html\b([^>]*)\blang="[^"]*"/i, `<html$1lang="${locale}"`);
+  else
+    html = html.replace(/<html\b([^>]*)>/i, `<html$1 lang="${locale}">`);
+  const localizedUrl = `${site.url.replace(/\/$/, "")}${localizePath(basePath, locale, i18n.defaultLocale)}`;
+  if (/<link rel="canonical"/.test(html))
+    html = html.replace(/<link rel="canonical"[^>]*>/, `<link rel="canonical" href="${escapeAttr(localizedUrl)}">`);
+  const ogLocale = locale.includes("_") || locale.includes("-") ? locale : locale.toLowerCase();
+  if (/<meta property="og:locale"/.test(html))
+    html = html.replace(/<meta property="og:locale"[^>]*>/, `<meta property="og:locale" content="${escapeAttr(ogLocale)}">`);
+  if (/<meta property="og:url"/.test(html))
+    html = html.replace(/<meta property="og:url"[^>]*>/, `<meta property="og:url" content="${escapeAttr(localizedUrl)}">`);
+  const alternates = buildAlternateLinks(site.url, basePath, i18n);
+  if (!html.includes("hreflang="))
+    html = html.replace(/<link rel="canonical"[^>]*>/, (m) => `${alternates}
+  ${m}`);
+  return html;
+}
+function escapeAttr(s) {
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function localizeInternalLinks(html, locale, defaultLocale, knownPaths) {
+  if (locale === defaultLocale)
+    return html;
+  return html.replace(/<a\b([^>]*?)\bhref="(\/[^"]*)"([^>]*)>/gi, (full, before, href, after) => {
+    if (href.startsWith("//"))
+      return full;
+    if (href === `/${locale}` || href === `/${locale}/` || href.startsWith(`/${locale}/`))
+      return full;
+    const m = href.match(/^(\/[^?#]*)(.*)$/);
+    if (!m)
+      return full;
+    const [, pathOnly, rest] = m, normalized = pathOnly === "/" ? "/" : pathOnly.replace(/\/$/, "");
+    if (!knownPaths.has(normalized))
+      return full;
+    const localized = normalized === "/" ? `/${locale}/` : `/${locale}${normalized}`;
+    return `<a${before}href="${localized}${rest}"${after}>`;
+  });
+}
+function autoWrapContent(html) {
+  if (/<main\b/i.test(html) || /\bdata-stx-content\b/i.test(html))
+    return html;
+  const bodyOpenMatch = html.match(/<body\b[^>]*>/i), bodyCloseIdx = html.search(/<\/body\s*>/i);
+  if (!bodyOpenMatch || bodyCloseIdx < 0)
+    return html;
+  const bodyContentStart = bodyOpenMatch.index + bodyOpenMatch[0].length, inner = html.slice(bodyContentStart, bodyCloseIdx);
+  let wrapStart = 0;
+  const navClose = [...inner.matchAll(/<\/nav>/gi)];
+  if (navClose.length > 0) {
+    const last = navClose[navClose.length - 1];
+    wrapStart = last.index + last[0].length;
+  }
+  let wrapEnd = inner.length;
+  const footerOpen = inner.search(/<footer\b/i);
+  if (footerOpen !== -1)
+    wrapEnd = Math.min(wrapEnd, footerOpen);
+  const trailingScript = inner.search(/<script\b[^>]*data-stx-(?:theme-toggle|reparent-progress)\b/i);
+  if (trailingScript !== -1)
+    wrapEnd = Math.min(wrapEnd, trailingScript);
+  if (wrapEnd <= wrapStart)
+    return html;
+  const middle = inner.slice(wrapStart, wrapEnd);
+  if (!middle.trim())
+    return html;
+  const newInner = `${inner.slice(0, wrapStart)}
+  <main>${middle}</main>
+${inner.slice(wrapEnd)}`;
+  return `${html.slice(0, bodyContentStart)}${newInner}${html.slice(bodyCloseIdx)}`;
+}
+function escapeText(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+export function defineSiteConfig(config) {
+  return config;
+}

package/dist/site-builder/i18n.d.ts

@@ -0,0 +1,104 @@
+import type { SiteConfig, SiteI18nOptions } from './types';
+export type { SiteI18nOptions };
+/**
+ * Resolve i18n config into the runtime shape used by the build.
+ *
+ * Translations are merged from two sources, in priority order:
+ *   1. `i18n.translations[<locale>]` — inline strings from `site.config.ts`
+ *   2. `<translationsDir>/<locale>.<format>` on disk — JSON or YAML files
+ *
+ * Inline strings win on key conflicts, so config-level overrides don't
+ * require editing the shared translation files. Missing locales/files
+ * are silently tolerated; the file loader returns `{}` for anything it
+ * can't read so the default locale's table can still serve as a
+ * fallback at translate-time.
+ */
+export declare function resolveI18n(site: SiteConfig, projectRoot?: string): ResolvedI18n | null;
+/**
+ * Translate a key for a locale, falling back to the default locale's
+ * value, then to the key itself. The fallback chain keeps prototypes
+ * shippable even when only a subset of strings is translated.
+ */
+export declare function translate(i18n: ResolvedI18n, locale: string, key: string): string;
+/**
+ * Replace `{t:key}` and `{t!:key}` markers in HTML with the translated
+ * string for the given locale. The key syntax sidesteps stx's
+ * `{{ ... }}` templating (which evaluates as JS at build time and
+ * would render `t(...)` calls as empty when no `t` binding exists
+ * in scope).
+ *
+ * Two variants:
+ *   - `{t:key}`  — value is HTML-escaped before substitution. Default
+ *     for ordinary text. Safe for any translator-supplied string.
+ *   - `{t!:key}` — value is substituted *raw*, without escaping. Use
+ *     this when the translation needs inline markup (e.g. `<strong>`,
+ *     `<a>`, `<br>`) so different languages can place emphasis where
+ *     their grammar requires. Translation values for these keys live
+ *     in the project's own translation files, so the trust boundary
+ *     is the same as the page template itself.
+ *
+ * Keys may use letters, digits, `_`, `.`, `-`. Anything that doesn't
+ * match the pattern is left alone — runs after stx has finished its
+ * own templating pass.
+ */
+export declare function applyTranslations(html: string, i18n: ResolvedI18n, locale: string): string;
+/**
+ * URL path for a built page in the given locale.
+ *
+ * - `/` stays `/` for the default locale; for non-default locales it
+ *   becomes `/<code>/` (with the trailing slash). The slash matters
+ *   because most static hosts (S3+CloudFront, GitHub Pages, etc.)
+ *   only serve the directory's `index.html` when the URL ends in `/`
+ *   — `/de` 404s, `/de/` resolves. Linking with the slash avoids a
+ *   client-side redirect dance and lets SPA hops succeed without
+ *   falling back to a full page load.
+ * - `/about` becomes `/<code>/about` for non-default locales (no
+ *   trailing slash — those map to `<code>/about.html`).
+ * - `/404.html` keeps its filename and lives under the locale prefix.
+ */
+export declare function localizePath(path: string, locale: string, defaultLocale: string): string;
+/**
+ * Reverse of `localizePath`: strip a locale prefix off a path so we
+ * can compute the equivalent path in another locale.
+ */
+export declare function stripLocalePrefix(path: string, locales: string[]): { locale: string | null, path: string };
+/**
+ * `<link rel="alternate" hreflang>` block + `<link rel="canonical">`
+ * for the page being rendered. Search engines treat each as the
+ * authoritative copy for its locale.
+ */
+export declare function buildAlternateLinks(siteUrl: string, pagePath: string, i18n: ResolvedI18n): string;
+/**
+ * Tag a rendered page with its locale, via the SPA router's "layout group".
+ *
+ * The router's default swap replaces the container only, so `<nav>` and
+ * `<footer>` keep the markup of whatever page loaded first. That is fine for
+ * a same-locale hop and wrong for every cross-locale one: the chrome holds
+ * `{t:key}` text and locale-prefixed hrefs, both of which the server already
+ * resolved for the *destination* locale. A differing layout group is the
+ * router's signal to swap the whole body instead, which brings the chrome
+ * along — still a client-side navigation, no reload.
+ *
+ * Both renderers call this. They used to each carry their own copy of the
+ * markup, and only the dev server's copy actually existed: the static build
+ * shipped no group meta at all, so a built site translated `<main>` on a
+ * language switch and left the nav in the previous language until a hard
+ * reload — the one place the bug could not be seen while developing.
+ */
+export declare function stampLocaleLayoutGroup(html: string, locale: string): string;
+/**
+ * Inline script that wires up the language picker.
+ *
+ * Per-page logic: each `<button data-lang="…">` inside the configured
+ * picker selector navigates to the equivalent path in the chosen
+ * locale, using the locale list shipped in `window.__stxI18n`. Marks
+ * the active button with `aria-current="true"` for styling.
+ */
+export declare function buildLangPickerScript(i18n: ResolvedI18n, currentLocale: string): string;
+export declare interface ResolvedI18n {
+  locales: string[]
+  defaultLocale: string
+  labels: Record<string, string>
+  translations: Record<string, Record<string, string>>
+  pickerSelector: string
+}

package/dist/site-builder/i18n.js

@@ -0,0 +1,150 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import process from "node:process";
+export function resolveI18n(site, projectRoot = process.cwd()) {
+  const i18n = site.i18n;
+  if (!i18n || !Array.isArray(i18n.locales) || i18n.locales.length === 0)
+    return null;
+  const defaultLocale = i18n.defaultLocale ?? i18n.locales[0], translations = mergeTranslations(i18n, projectRoot);
+  return {
+    locales: i18n.locales,
+    defaultLocale,
+    labels: i18n.labels ?? Object.fromEntries(i18n.locales.map((c) => [c, c.toUpperCase()])),
+    translations,
+    pickerSelector: i18n.pickerSelector ?? "#lang-picker"
+  };
+}
+function mergeTranslations(i18n, projectRoot) {
+  const inline = i18n.translations ?? {}, out = {}, dir = i18n.translationsDir, dirAbs = dir === !1 ? null : resolve(projectRoot, typeof dir === "string" && dir ? dir : "translations"), format = i18n.format ?? "json";
+  for (const locale of i18n.locales) {
+    const fromFile = dirAbs ? loadFromFile(dirAbs, locale, format) : {};
+    out[locale] = { ...fromFile, ...inline[locale] ?? {} };
+  }
+  return out;
+}
+function loadFromFile(dir, locale, format) {
+  const candidates = format === "json" ? [`${locale}.json`] : [`${locale}.${format}`, `${locale}.${format === "yaml" ? "yml" : "yaml"}`];
+  for (const name of candidates) {
+    const file = join(dir, name);
+    if (!existsSync(file))
+      continue;
+    try {
+      const raw = readFileSync(file, "utf8"), data = format === "json" ? JSON.parse(raw) : parseSimpleYaml(raw);
+      return flatten(data);
+    } catch {
+      continue;
+    }
+  }
+  return {};
+}
+function flatten(obj, prefix = "", out = {}) {
+  if (!obj || typeof obj !== "object")
+    return out;
+  for (const [k, v] of Object.entries(obj)) {
+    const key = prefix ? `${prefix}.${k}` : k;
+    if (v && typeof v === "object" && !Array.isArray(v))
+      flatten(v, key, out);
+    else if (typeof v === "string")
+      out[key] = v;
+    else if (typeof v === "number" || typeof v === "boolean")
+      out[key] = String(v);
+  }
+  return out;
+}
+function parseSimpleYaml(content) {
+  const result = {}, stack = [{ obj: result, indent: -1 }];
+  for (const rawLine of content.split(`
+`)) {
+    const line = rawLine.replace(/#.*$/, "").trimEnd();
+    if (!line.trim())
+      continue;
+    const indent = line.search(/\S/);
+    if (indent === -1)
+      continue;
+    while (stack.length > 1 && stack[stack.length - 1].indent >= indent)
+      stack.pop();
+    const currentObj = stack[stack.length - 1].obj, match = line.match(/^(\s*)(\S[^:]*):\s*(.*)$/);
+    if (!match)
+      continue;
+    const [, , key, rawValue] = match, trimmedKey = key.trim(), trimmedValue = rawValue.trim();
+    if (trimmedValue === "") {
+      currentObj[trimmedKey] = {};
+      stack.push({ obj: currentObj[trimmedKey], indent });
+    } else
+      currentObj[trimmedKey] = unquote(trimmedValue);
+  }
+  return result;
+}
+function unquote(v) {
+  if (v.startsWith("'") && v.endsWith("'") || v.startsWith('"') && v.endsWith('"'))
+    return v.slice(1, -1);
+  return v;
+}
+export function translate(i18n, locale, key) {
+  const local = i18n.translations[locale]?.[key];
+  if (typeof local === "string")
+    return local;
+  const fallback = i18n.translations[i18n.defaultLocale]?.[key];
+  if (typeof fallback === "string")
+    return fallback;
+  return key;
+}
+export function applyTranslations(html, i18n, locale) {
+  return html.replace(/\{t(!?):([a-zA-Z][\w.-]*)\}/g, (_match, raw, key) => {
+    const value = translate(i18n, locale, key);
+    return raw === "!" ? value : escapeHtml(value);
+  });
+}
+export function localizePath(path, locale, defaultLocale) {
+  if (locale === defaultLocale)
+    return path;
+  if (path === "/")
+    return `/${locale}/`;
+  if (path === "/404.html")
+    return `/${locale}/404.html`;
+  return `/${locale}${path}`;
+}
+export function stripLocalePrefix(path, locales) {
+  for (const loc of locales) {
+    if (path === `/${loc}` || path === `/${loc}/`)
+      return { locale: loc, path: "/" };
+    if (path.startsWith(`/${loc}/`))
+      return { locale: loc, path: path.slice(loc.length + 1) };
+  }
+  return { locale: null, path };
+}
+export function buildAlternateLinks(siteUrl, pagePath, i18n) {
+  const base = siteUrl.replace(/\/$/, ""), lines = [];
+  for (const loc of i18n.locales) {
+    const url = `${base}${localizePath(pagePath, loc, i18n.defaultLocale)}`;
+    lines.push(`<link rel="alternate" hreflang="${escapeAttr(loc)}" href="${escapeAttr(url)}">`);
+  }
+  const def = `${base}${localizePath(pagePath, i18n.defaultLocale, i18n.defaultLocale)}`;
+  lines.push(`<link rel="alternate" hreflang="x-default" href="${escapeAttr(def)}">`);
+  return lines.join(`
+  `);
+}
+export function stampLocaleLayoutGroup(html, locale) {
+  const groupMeta = `<meta name="stx-layout-group" content="i18n:${escapeAttr(locale)}">`;
+  if (/<meta name="stx-layout-group"[^>]*>/i.test(html))
+    return html.replace(/<meta name="stx-layout-group"[^>]*>/i, groupMeta);
+  if (/<\/head>/i.test(html))
+    return html.replace(/<\/head>/i, `${groupMeta}
+</head>`);
+  return `${groupMeta}
+${html}`;
+}
+export function buildLangPickerScript(i18n, currentLocale) {
+  return `<script data-stx-lang-picker="1">window.__stxI18n=${JSON.stringify({
+    locales: i18n.locales,
+    defaultLocale: i18n.defaultLocale,
+    current: currentLocale,
+    pickerSelector: i18n.pickerSelector
+  })};(function(){function cfg(){return window.__stxI18n}function localeFromPath(p){var d=cfg();for(var i=0;i<d.locales.length;i++){var c=d.locales[i];if(p==='/'+c||p==='/'+c+'/')return c;if(p.indexOf('/'+c+'/')===0)return c}return d.defaultLocale}function localePathFor(loc,p){var d=cfg();var stripped=p;for(var i=0;i<d.locales.length;i++){var c=d.locales[i];if(p==='/'+c||p==='/'+c+'/'){stripped='/';break}if(p.indexOf('/'+c+'/')===0){stripped=p.slice(c.length+1);break}}if(loc===d.defaultLocale)return stripped;if(stripped==='/')return '/'+loc+'/';return '/'+loc+stripped}cfg().localizeHref=function(href){try{var u=new URL(href,location.origin);if(u.origin!==location.origin)return href;return localePathFor(localeFromPath(location.pathname),u.pathname)+(u.search||'')+(u.hash||'')}catch(_){return href}};function syncFromUrl(){var d=cfg();var loc=localeFromPath(location.pathname);d.current=loc;var picker=document.querySelector(d.pickerSelector);if(picker){var btns=picker.querySelectorAll('[data-lang]');for(var i=0;i<btns.length;i++){var b=btns[i];if(b.getAttribute('data-lang')===loc)b.setAttribute('aria-current','true');else b.removeAttribute('aria-current')}}if(document.documentElement.lang!==loc)document.documentElement.lang=loc}function onLangClick(e){var d=cfg();var btn=e.target&&e.target.closest&&e.target.closest('[data-lang]');if(!btn)return;var picker=document.querySelector(d.pickerSelector);if(!picker||!picker.contains(btn))return;e.preventDefault();e.stopPropagation();var loc=btn.getAttribute('data-lang');if(!loc||loc===localeFromPath(location.pathname))return;var dest=localePathFor(loc,location.pathname);var r=window.__stxRouter;if(r&&r.navigate)r.navigate(dest,true,true);else location.assign(dest)}syncFromUrl();if(window.__stxLangPickerBound){document.removeEventListener('click',window.__stxLangPickerClick,true);window.removeEventListener('stx:navigate',window.__stxLangPickerSync);window.removeEventListener('popstate',window.__stxLangPickerSync)}window.__stxLangPickerClick=onLangClick;window.__stxLangPickerSync=syncFromUrl;window.__stxLangPickerBound=1;document.addEventListener('click',onLangClick,true);window.addEventListener('stx:navigate',syncFromUrl);window.addEventListener('popstate',syncFromUrl)})();</script>`;
+}
+function escapeAttr(s) {
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}

package/dist/site-builder/index.d.ts

@@ -0,0 +1,27 @@
+export type { ResolvedI18n } from './i18n';
+export type {
+  BuildOptions,
+  PageMeta,
+  SiteConfig,
+  SiteI18nOptions,
+  SiteRouterOptions,
+  SiteSeo,
+  SiteSocial,
+  SiteThemeOptions,
+} from './types';
+export { buildStaticSite, defineSiteConfig, type BuildResult } from './build';
+export { injectSeo } from './seo';
+export { generateSitemap, type SitemapEntry } from './sitemap';
+export { generateRobots } from './robots';
+export { injectRouterScript, type RouterOptions } from './router';
+export { injectThemeBootstrap, type ThemeOptions } from './theme';
+export {
+  applyTranslations,
+  buildAlternateLinks,
+  buildLangPickerScript,
+  localizePath,
+  resolveI18n,
+  stampLocaleLayoutGroup,
+  stripLocalePrefix,
+  translate,
+} from './i18n';

package/dist/site-builder/index.js

@@ -0,0 +1,16 @@
+export { buildStaticSite, defineSiteConfig } from "./build.js";
+export { injectSeo } from "./seo.js";
+export { generateSitemap } from "./sitemap.js";
+export { generateRobots } from "./robots.js";
+export { injectRouterScript } from "./router.js";
+export { injectThemeBootstrap } from "./theme.js";
+export {
+  applyTranslations,
+  buildAlternateLinks,
+  buildLangPickerScript,
+  localizePath,
+  resolveI18n,
+  stampLocaleLayoutGroup,
+  stripLocalePrefix,
+  translate
+} from "./i18n.js";

package/dist/site-builder/robots.d.ts

@@ -0,0 +1,2 @@
+import type { SiteConfig } from './types';
+export declare function generateRobots(site: SiteConfig): string | null;

package/dist/site-builder/robots.js

@@ -0,0 +1,26 @@
+export function generateRobots(site) {
+  const mode = site.robots ?? "allow";
+  if (mode === !1)
+    return null;
+  if (typeof mode === "string" && mode !== "allow" && mode !== "disallow")
+    return mode.endsWith(`
+`) ? mode : `${mode}
+`;
+  const sitemapLine = site.sitemap !== !1 ? `Sitemap: ${site.url.replace(/\/$/, "")}/sitemap.xml
+` : "";
+  if (mode === "disallow")
+    return [
+      "User-agent: *",
+      "Disallow: /",
+      "",
+      sitemapLine
+    ].filter(Boolean).join(`
+`);
+  return [
+    "User-agent: *",
+    "Allow: /",
+    "",
+    sitemapLine
+  ].filter(Boolean).join(`
+`);
+}

package/dist/site-builder/router.d.ts

@@ -0,0 +1,10 @@
+import type { SiteRouterOptions } from './types';
+/**
+ * Inject the stx SPA router into HTML. The script is appended just
+ * before `</body>` (or at the end of the document if there is no body
+ * close). Configuration from `options` is exposed as
+ * `window.__stxRouterConfig` ahead of the runtime so the runtime picks
+ * it up on init.
+ */
+export declare function injectRouterScript(html: string, options?: RouterOptions): Promise<string>;
+export type RouterOptions = SiteRouterOptions;

package/dist/site-builder/router.js

@@ -0,0 +1,27 @@
+let _cachedRouterScript = null;
+async function getRouterScript() {
+  if (_cachedRouterScript !== null)
+    return _cachedRouterScript;
+  try {
+    const mod = await import("stx-router");
+    if (typeof mod.getRouterScript === "function")
+      _cachedRouterScript = mod.getRouterScript();
+    else
+      _cachedRouterScript = "";
+  } catch {
+    _cachedRouterScript = "";
+  }
+  return _cachedRouterScript;
+}
+export async function injectRouterScript(html, options) {
+  const script = await getRouterScript();
+  if (!script)
+    return html;
+  const merged = { interceptAllLinks: !0, container: "main", ...options }, block = `${`<script>window.__stxRouterConfig=${JSON.stringify(merged)};</script>
+`}<script>${script}</script>`;
+  if (/<\/body>/i.test(html))
+    return html.replace(/<\/body>/i, `${block}
+</body>`);
+  return `${html}
+${block}`;
+}

package/dist/site-builder/seo.d.ts

@@ -0,0 +1,8 @@
+import type { PageMeta, SiteConfig } from './types';
+/**
+ * Replace stx's auto-injected default SEO block (which says "stx Project")
+ * with site-specific tags. Looks for the marker comment stx inserts and
+ * swaps the wrapped meta tags. If the block isn't found, prepends the
+ * tags after <head>.
+ */
+export declare function injectSeo(html: string, site: SiteConfig, page?: PageMeta, pagePath?: string): string;