@uniweb/runtime 0.14.0 → 0.14.2

package/dist/ssr.js

@@ -1,8 +1,15 @@
-import { isRichSchema, deriveCacheKey, resolveDefaultLocale, hasDarkScheme, createUniweb } from "@uniweb/core";
+import { isRichSchema, deriveCacheKey, resolveDefaultLocale, hasDarkScheme, createUniweb, resolveRequestStyle, resolveServiceUrl, substitutePlaceholders, matchWhere } from "@uniweb/core";
 import React from "react";
 import { renderToString } from "react-dom/server";
 import { sectionDomId } from "@uniweb/core/section-id";
+import { routePatternToRegex } from "@uniweb/core/route-match";
+import { DEFAULT_ICON_BASE, iconUrl } from "@uniweb/core/icon-corpus";
 import { buildTheme, FONT_LINKS_MARKER, buildSectionOverrides } from "@uniweb/theming";
+import "@uniweb/core/services";
+import "@uniweb/core/tracker";
+import { resolveFetchConfigs } from "@uniweb/core/fetch-config";
+import { deriveCacheKey as deriveCacheKey$1 } from "@uniweb/core/datastore";
+import { resolveDefaultLocale as resolveDefaultLocale$1 } from "@uniweb/core/locale-config";
 function guaranteeItemStructure(item) {
   return {
     title: item.title || "",
@@ -240,27 +247,6 @@ function getComponentMeta(componentName) {
 function getComponentDefaults(componentName) {
   return globalThis.uniweb?.getComponentDefaults?.(componentName) || {};
 }
-const PARAM_NAME = "[A-Za-z0-9_-]+";
-const REGEX_SPECIALS = /[.*+?^${}()|[\]\\]/g;
-function normalizeRoute(route) {
-  if (typeof route !== "string" || route === "") return "/";
-  return route === "/" ? "/" : route.replace(/\/+$/, "") || "/";
-}
-function routePatternToRegex(pattern) {
-  const paramNames = [];
-  const source = normalizeRoute(pattern).replace(REGEX_SPECIALS, "\\$&").replace(new RegExp(`:(${PARAM_NAME})`, "g"), (_, name) => {
-    paramNames.push(name);
-    return "([^/]+)";
-  });
-  return { regex: new RegExp(`^${source}$`), paramNames };
-}
-const DEFAULT_ICON_BASE = "https://uniweb.github.io/icons";
-function iconPath(family, name) {
-  return `${family}/${family}-${name}.svg`;
-}
-function iconUrl(family, name, base = DEFAULT_ICON_BASE) {
-  return `${String(base).replace(/\/+$/, "")}/${iconPath(family, name)}`;
-}
 function default404Html(basePath = "") {
   const homeHref = basePath ? `${basePath}/` : "/";
   return `<div class="page-not-found" style="min-height:80vh;display:flex;flex-direction:column;align-items:center;justify-content:center;padding:2rem;text-align:center"><h1 style="font-size:3rem;font-weight:bold;color:#1f2937;margin-bottom:1rem">404</h1><p style="color:#64748b;margin-bottom:2rem">Page not found</p><a href="${homeHref}" style="color:#3b82f6;text-decoration:underline">Go to homepage</a></div>`;
@@ -298,6 +284,7 @@ function sliceContentForLocale(content, locale) {
 function hydrateDataStore(website, fetchedData) {
   if (!website?.dataStore || !fetchedData?.length) return;
   for (const entry of fetchedData) {
+    if (entry.outcome && entry.outcome !== "fetched") continue;
     website.dataStore.set(deriveCacheKey(entry.config), { data: entry.data });
   }
 }
@@ -851,11 +838,376 @@ function generate404Html({ baseHtml, website, siteContent }) {
   }
   return { html, hasNotFoundPage: !!notFoundPage };
 }
+const KNOWN_OPERATORS = /* @__PURE__ */ new Set(["where", "limit", "sort"]);
+function createDefaultFetcher({ basePath = "", config = {}, dev = false, records = null, fetch: fetchImpl = null } = {}) {
+  const doFetch = (input, init) => (fetchImpl || globalThis.fetch)(input, init);
+  const pathPrefix = basePath && basePath !== "/" ? basePath.replace(/\/$/, "") : "";
+  const baseUrl = typeof config?.baseUrl === "string" ? config.baseUrl.replace(/\/$/, "") : "";
+  const staticHeaders = buildStaticHeaders(config?.headers);
+  const supports = normalizeSupports(config?.supports);
+  const requestConfig = config?.request && typeof config.request === "object" ? config.request : {};
+  const styleName = typeof requestConfig.style === "string" ? requestConfig.style : null;
+  const style = resolveRequestStyle(styleName, { dev });
+  const rename = normalizeRename(requestConfig.rename, style, { dev });
+  const siteEnvelope = config?.envelope && typeof config.envelope === "object" ? config.envelope : null;
+  const envelope = { ...style.defaultEnvelope || {}, ...siteEnvelope || {} };
+  const stampedArrayKey = records?.envelope && typeof records.envelope === "object" && typeof records.envelope.records === "string" && records.envelope.records.length ? records.envelope.records : null;
+  const laneEnvelope = stampedArrayKey ? { list: stampedArrayKey } : null;
+  return {
+    /**
+     * Cache-key function. The default-fetcher's cache key includes only
+     * the operators it pushes down (because they affect what the source
+     * sees). Operators applied as runtime fallback operate on a shared
+     * cached value and therefore must NOT split the cache.
+     *
+     * Example: with `supports: []`, two pages declaring different
+     * `where:` clauses against the same path share one cache entry —
+     * the file is fetched once and each page filters its own copy. With
+     * `supports: [where]`, the same two pages fire two requests because
+     * the predicate travels in the request.
+     */
+    cacheKey(request) {
+      const base = deriveCacheKey(request);
+      const projected = {};
+      for (const op of supports) {
+        if (!style.canPush.has(op)) continue;
+        if (request[op] !== void 0) projected[op] = request[op];
+      }
+      if (Object.keys(projected).length === 0 && style.name === "json-body") {
+        return base;
+      }
+      return base + "::style=" + style.name + "::" + JSON.stringify(projected);
+    },
+    async resolve(request, ctx = {}) {
+      if (!request) return { data: null };
+      const { path, url, endpoint, transform, body: rawBody } = request;
+      let method = (request.method || "GET").toUpperCase();
+      if (method !== "GET" && method !== "POST") {
+        console.warn(`[default-fetcher] method "${request.method}" is not supported — falling back to GET.`);
+        method = "GET";
+      }
+      let target;
+      let isRemote;
+      if (endpoint) {
+        target = resolveServiceUrl(endpoint, pathPrefix);
+        isRemote = true;
+      } else if (path) {
+        target = pathPrefix && path.startsWith("/") && !path.startsWith("//") ? pathPrefix + path : path;
+        isRemote = false;
+      } else if (url) {
+        target = isAbsoluteUrl(url) ? url : joinUrl(baseUrl, url);
+        isRemote = true;
+      } else {
+        return { data: [], error: "No path, url or endpoint specified" };
+      }
+      const init = { signal: ctx.signal, method };
+      const headers = {};
+      if (isRemote && staticHeaders) Object.assign(headers, staticHeaders);
+      const pushCandidates = /* @__PURE__ */ new Set();
+      if (isRemote) {
+        for (const op of KNOWN_OPERATORS) {
+          if (supports.has(op) && style.canPush.has(op) && request[op] !== void 0 && request[op] !== null) {
+            pushCandidates.add(op);
+          }
+        }
+      }
+      const encoded = pushCandidates.size > 0 ? style.encode(request, { method, pushCandidates, rename }) : { queryParams: [], bodyMerge: null, pushed: /* @__PURE__ */ new Set() };
+      const pushedOperators = encoded.pushed;
+      if (encoded.queryParams.length > 0 && method === "GET") {
+        target = appendStyleQueryParams(target, encoded.queryParams);
+      }
+      if (method === "POST") {
+        const dc = request.dynamicContext;
+        const resolvedBody = rawBody !== void 0 && rawBody !== null && dc && dc.paramName ? substitutePlaceholders(rawBody, { [dc.paramName]: dc.paramValue }, { encode: false }) : rawBody;
+        const finalBody = composePostBody(resolvedBody, encoded.bodyMerge);
+        if (finalBody !== null) {
+          if (!hasHeader(headers, "Content-Type")) {
+            headers["Content-Type"] = "application/json";
+          }
+          init.body = typeof finalBody === "string" ? finalBody : JSON.stringify(finalBody);
+        }
+      }
+      if (Object.keys(headers).length) init.headers = headers;
+      try {
+        const response = await doFetch(target, init);
+        const requestEnvelope = request.envelope && typeof request.envelope === "object" ? request.envelope : null;
+        const effectiveEnvelope = requestEnvelope ?? (endpoint && laneEnvelope ? { ...envelope, ...laneEnvelope } : envelope);
+        if (!response.ok) {
+          let extracted;
+          if (effectiveEnvelope.error) {
+            try {
+              const text = await response.text();
+              const body = safeParseJSON(text);
+              if (body !== void 0) {
+                const candidate = getNestedValue(body, effectiveEnvelope.error);
+                if (typeof candidate === "string" && candidate.length) {
+                  extracted = candidate;
+                }
+              }
+            } catch {
+            }
+          }
+          return {
+            data: [],
+            error: extracted ?? `HTTP ${response.status}: ${response.statusText}`
+          };
+        }
+        const contentType = response.headers.get("content-type") || "";
+        let data;
+        if (contentType.includes("application/json")) {
+          data = await response.json();
+        } else {
+          const text = await response.text();
+          try {
+            data = JSON.parse(text);
+          } catch {
+            data = text;
+          }
+        }
+        const isDetailRequest = !!request.dynamicContext;
+        const effectiveTransform = transform || (isDetailRequest ? effectiveEnvelope.item : effectiveEnvelope.list);
+        if (effectiveTransform && data !== null && data !== void 0) {
+          data = getNestedValue(data, effectiveTransform);
+        }
+        data = applyFallbackOperators(data, request, pushedOperators);
+        return { data: data ?? [] };
+      } catch (error) {
+        if (error?.name === "AbortError") {
+          return { data: [], error: "aborted" };
+        }
+        return { data: [], error: error?.message || String(error) };
+      }
+    }
+  };
+}
+function normalizeRename(raw, style, { dev }) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const out = {};
+  for (const [op, wireName] of Object.entries(raw)) {
+    if (typeof wireName !== "string" || wireName.length === 0) continue;
+    if (dev && !style.canPush.has(op) && !warnedRenameTargets.has(op)) {
+      warnedRenameTargets.add(op);
+      console.warn(
+        `[default-fetcher] request.rename: operator "${op}" is not pushed by style "${style.name}" — rename has no effect. Known operators for this style: ${[...style.canPush].join(", ") || "(none)"}.`
+      );
+    }
+    out[op] = wireName;
+  }
+  return Object.keys(out).length ? out : null;
+}
+const warnedRenameTargets = /* @__PURE__ */ new Set();
+function normalizeSupports(raw) {
+  const out = /* @__PURE__ */ new Set();
+  if (!Array.isArray(raw)) return out;
+  for (const op of raw) {
+    if (typeof op !== "string") continue;
+    if (KNOWN_OPERATORS.has(op)) out.add(op);
+    else if (!warnedUnknownOperators.has(op)) {
+      warnedUnknownOperators.add(op);
+      console.warn(`[default-fetcher] supports: unknown operator "${op}" — ignored.`);
+    }
+  }
+  return out;
+}
+const warnedUnknownOperators = /* @__PURE__ */ new Set();
+function appendStyleQueryParams(url, pairs) {
+  if (!pairs || pairs.length === 0) return url;
+  const params = pairs.map(
+    ([k, v]) => encodeURIComponent(k) + "=" + encodeURIComponent(v)
+  );
+  const sep = url.includes("?") ? "&" : "?";
+  return url + sep + params.join("&");
+}
+function composePostBody(authorBody, bodyMerge) {
+  if (!bodyMerge) {
+    return authorBody === void 0 ? null : authorBody;
+  }
+  if (typeof authorBody === "string") {
+    return authorBody;
+  }
+  const base = authorBody && typeof authorBody === "object" ? authorBody : {};
+  return { ...base, ...bodyMerge };
+}
+function applyFallbackOperators(data, request, pushedOperators) {
+  if (!Array.isArray(data)) return data;
+  let result = data;
+  if (request.where && !pushedOperators.has("where")) {
+    result = matchWhere(request.where, result);
+  }
+  if (request.sort && !pushedOperators.has("sort")) {
+    result = applySortFallback(result, request.sort);
+  }
+  if (typeof request.limit === "number" && request.limit > 0 && !pushedOperators.has("limit")) {
+    result = result.slice(0, request.limit);
+  }
+  return result;
+}
+function applySortFallback(items, sortExpr) {
+  const sorts = String(sortExpr).split(",").map((s) => {
+    const [field, dir = "asc"] = s.trim().split(/\s+/);
+    return { field, desc: dir.toLowerCase() === "desc" };
+  });
+  return [...items].sort((a, b) => {
+    for (const { field, desc } of sorts) {
+      const av = getNestedValue(a, field) ?? "";
+      const bv = getNestedValue(b, field) ?? "";
+      if (av < bv) return desc ? 1 : -1;
+      if (av > bv) return desc ? -1 : 1;
+    }
+    return 0;
+  });
+}
+function buildStaticHeaders(headers) {
+  if (!headers || typeof headers !== "object" || Array.isArray(headers)) return null;
+  const out = {};
+  for (const [k, v] of Object.entries(headers)) {
+    if (v === null || v === void 0) continue;
+    out[k] = String(v);
+  }
+  return Object.keys(out).length ? out : null;
+}
+function hasHeader(headers, name) {
+  const lower = name.toLowerCase();
+  return Object.keys(headers).some((k) => k.toLowerCase() === lower);
+}
+function isAbsoluteUrl(url) {
+  if (typeof url !== "string") return false;
+  if (url.startsWith("//")) return true;
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(url);
+}
+function joinUrl(baseUrl, url) {
+  if (!baseUrl) return url;
+  if (url.startsWith("/")) return baseUrl + url;
+  return baseUrl + "/" + url;
+}
+function getNestedValue(obj, path) {
+  if (!obj || !path) return obj;
+  let current = obj;
+  for (const part of path.split(".")) {
+    if (current === null || current === void 0) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function safeParseJSON(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+const isRefinement = (f) => f && typeof f === "object" && f.refine === true;
+function findPageForRoute(content, route) {
+  const pages = content?.pages || [];
+  const exact = pages.find((p) => p.route === route);
+  if (exact) return { page: exact, params: {} };
+  for (const page of pages) {
+    if (!page.isDynamic || !page.route) continue;
+    const compiled = routePatternToRegex(page.route);
+    const m = compiled?.regex ? compiled.regex.exec(route) : null;
+    if (m) return { page, params: Object.fromEntries((compiled.paramNames || []).map((n, i) => [n, m[i + 1]])) };
+  }
+  return { page: null, params: {} };
+}
+function resolvePageFetchConfigs(content, route, { locale = null } = {}) {
+  const { page } = findPageForRoute(content, route);
+  if (!page) return [];
+  const pages = content?.pages || [];
+  const parent = page.parent ? pages.find((p) => p.route === page.parent) : null;
+  const options = {
+    locale,
+    defaultLocale: resolveDefaultLocale$1(content?.config) ?? null,
+    queries: content?.config?.queries ?? null,
+    records: content?.config?.records ?? null
+  };
+  const out = /* @__PURE__ */ new Map();
+  const add = (sources) => {
+    for (const cfg of resolveFetchConfigs(sources, options).values()) {
+      const key = deriveCacheKey$1(cfg);
+      if (!out.has(key)) out.set(key, cfg);
+    }
+  };
+  add([page.fetch ?? null, parent?.fetch ?? null, content?.config?.fetch ?? null]);
+  const walk = (sections) => {
+    for (const s of sections || []) {
+      if (s?.fetch && !isRefinement(s.fetch)) add([s.fetch, page.fetch ?? null, parent?.fetch ?? null, content?.config?.fetch ?? null]);
+      if (s?.subsections) walk(s.subsections);
+    }
+  };
+  walk(page.sections);
+  return [...out.values()];
+}
+async function executeFetchConfigs(configs, { content, fetch: fetch2 = null, dev = false, prerender = "always" } = {}) {
+  if (prerender !== "author" && prerender !== "always") {
+    throw new Error(`executeFetchConfigs: prerender must be 'author' or 'always', got ${JSON.stringify(prerender)}`);
+  }
+  const fetcher = createDefaultFetcher({
+    basePath: content?.config?.base || "",
+    config: content?.config?.fetcher ?? {},
+    records: content?.config?.records ?? null,
+    dev,
+    fetch: fetch2
+  });
+  const ctx = { website: null };
+  const out = [];
+  for (const config of configs || []) {
+    if (!config) continue;
+    if (prerender === "author" && config.prerender === false) {
+      out.push({ config, outcome: "skipped", data: null });
+      continue;
+    }
+    const result = await fetcher.resolve(config, ctx);
+    if (result?.error) out.push({ config, outcome: "failed", data: null, error: result.error });
+    else out.push({ config, outcome: "fetched", data: result?.data ?? null });
+  }
+  return out;
+}
+async function prefetchPageData({ content, route, locale = null, fetch: fetch2 = null, dev = false, prerender = "always" }) {
+  const configs = resolvePageFetchConfigs(content, route, { locale });
+  return executeFetchConfigs(configs, { content, fetch: fetch2, dev, prerender });
+}
+function createPageRenderer({ website, shell }) {
+  if (!website) throw new Error("createPageRenderer: `website` is required");
+  if (typeof shell !== "string") throw new Error("createPageRenderer: `shell` must be an HTML string");
+  function render(target, { inject = {} } = {}) {
+    const page = typeof target === "string" ? resolvePage(website, target) : target;
+    if (!page) return { outcome: "notFound", html: null, page: null, error: null };
+    let result;
+    try {
+      result = renderPage(page, website);
+    } catch (err) {
+      return { outcome: "failed", html: null, page, error: classifyRenderError(err) };
+    }
+    if (result.error) return { outcome: "failed", html: null, page, error: result.error };
+    const html = injectPageContent(shell, result.renderedContent, page, {
+      ...inject,
+      sectionOverrideCSS: result.sectionOverrideCSS
+    });
+    return { outcome: "rendered", html, page, error: null };
+  }
+  return { website, render };
+}
+async function prefetchAndHydrate({ website, content, route, locale = null, fetch: fetch2 = null, dev = false, prerender = "always" }) {
+  if (!website?.dataStore) {
+    throw new Error("prefetchAndHydrate: `website` must be an initialized Website with a dataStore");
+  }
+  if (typeof fetch2 !== "function") {
+    throw new Error(
+      "prefetchAndHydrate: `fetch` must be a function. A transport does not survive a JSON-serialized isolate boundary — pass it as an RPC method argument. To use the ambient fetch deliberately, pass `fetch: globalThis.fetch`."
+    );
+  }
+  const fetched = await prefetchPageData({ content, route, locale, fetch: fetch2, dev, prerender });
+  hydrateDataStore(website, fetched);
+  return fetched;
+}
 export {
   applyDefaults,
   applySchemas,
   classifyRenderError,
+  createPageRenderer,
   escapeHtml,
+  executeFetchConfigs,
+  findPageForRoute,
   generate404Html,
   getComponentDefaults,
   getComponentMeta,
@@ -865,7 +1217,9 @@ export {
   initPrerender,
   initPrerenderForLocale,
   injectPageContent,
+  prefetchAndHydrate,
   prefetchIcons,
+  prefetchPageData,
   prepareProps,
   renderAppearanceBootScript,
   renderBackground,
@@ -874,6 +1228,7 @@ export {
   renderLayout,
   renderPage,
   resolvePage,
+  resolvePageFetchConfigs,
   sliceContentForLocale
 };
 //# sourceMappingURL=ssr.js.map