@uniweb/runtime 0.14.0 → 0.14.1

package/dist/ssr.js

@@ -1,4 +1,4 @@
-import { isRichSchema, deriveCacheKey, resolveDefaultLocale, hasDarkScheme, createUniweb } from "@uniweb/core";
+import { isRichSchema, deriveCacheKey as deriveCacheKey$1, resolveDefaultLocale as resolveDefaultLocale$1, hasDarkScheme, createUniweb, resolveRequestStyle, resolveServiceUrl, substitutePlaceholders as substitutePlaceholders$1, matchWhere } from "@uniweb/core";
 import React from "react";
 import { renderToString } from "react-dom/server";
 import { sectionDomId } from "@uniweb/core/section-id";
@@ -282,7 +282,7 @@ function wireFoundationCapabilities(uniweb, foundation) {
   }
 }
 function sliceContentForLocale(content, locale) {
-  const defaultLang = resolveDefaultLocale(content?.config);
+  const defaultLang = resolveDefaultLocale$1(content?.config);
   const locData = content?.locales?.[locale];
   if (!locale || locale === defaultLang || !locData) return content;
   return {
@@ -298,7 +298,8 @@ function sliceContentForLocale(content, locale) {
 function hydrateDataStore(website, fetchedData) {
   if (!website?.dataStore || !fetchedData?.length) return;
   for (const entry of fetchedData) {
-    website.dataStore.set(deriveCacheKey(entry.config), { data: entry.data });
+    if (entry.outcome && entry.outcome !== "fetched") continue;
+    website.dataStore.set(deriveCacheKey$1(entry.config), { data: entry.data });
   }
 }
 function ensureThemeCss(uniweb, foundation) {
@@ -627,7 +628,7 @@ function renderLayout(page, website) {
 function initPrerenderForLocale(content, foundation, locale, extensionsOrOptions, maybeOptions) {
   const localeContent = sliceContentForLocale(content, locale);
   const uniweb = initPrerender(localeContent, foundation, extensionsOrOptions, maybeOptions);
-  const defaultLang = resolveDefaultLocale(content?.config);
+  const defaultLang = resolveDefaultLocale$1(content?.config);
   if (locale && locale !== defaultLang && uniweb.activeWebsite?.setActiveLocale) {
     uniweb.activeWebsite.setActiveLocale(locale);
   }
@@ -851,11 +852,504 @@ function generate404Html({ baseHtml, website, siteContent }) {
   }
   return { html, hasNotFoundPage: !!notFoundPage };
 }
+const DATA_DIR = "data";
+const DATA_URL_PREFIX = `/${DATA_DIR}/`;
+function queryDataUrl(name) {
+  return `${DATA_URL_PREFIX}${name}.json`;
+}
+function recordDataUrl(query, slug) {
+  return `${DATA_URL_PREFIX}${query}/${slug}.json`;
+}
+function isDataUrl(path) {
+  return typeof path === "string" && path.startsWith(DATA_URL_PREFIX);
+}
+const PLACEHOLDER_RE = /\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+function substitutePlaceholders(value, context, options = {}) {
+  const { encode = true } = options;
+  if (typeof value === "string") {
+    return value.replace(PLACEHOLDER_RE, (literal, key) => {
+      if (!(key in (context || {}))) return literal;
+      const raw = context[key];
+      if (raw === void 0 || raw === null) return literal;
+      return encode ? encodeURIComponent(String(raw)) : String(raw);
+    });
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => substitutePlaceholders(item, context, options));
+  }
+  if (value && typeof value === "object") {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      result[key] = substitutePlaceholders(value[key], context, options);
+    }
+    return result;
+  }
+  return value;
+}
+const PATH_SLOT = "{path}";
+const PARAM_SLOT = "{param}";
+const warnedPatterns = /* @__PURE__ */ new Set();
+function warnOnce(key, message) {
+  if (warnedPatterns.has(key)) return;
+  warnedPatterns.add(key);
+  console.warn(`[query-address] ${message}`);
+}
+function readPattern(lane, key) {
+  if (!lane || typeof lane !== "object" || Array.isArray(lane)) return null;
+  const pattern = lane[key];
+  return typeof pattern === "string" && pattern.length > 0 ? pattern : null;
+}
+function resolveQueryAddress(query, lane) {
+  if (typeof query !== "string" || query.length === 0) return null;
+  const pattern = readPattern(lane, "list");
+  if (!pattern) return null;
+  if (!pattern.includes(PATH_SLOT)) {
+    warnOnce(
+      `list:${pattern}`,
+      `config.records.list carries no ${PATH_SLOT} placeholder, so every query would resolve to the same address. Ignoring it and reading the compiled file instead.`
+    );
+    return null;
+  }
+  return substitutePlaceholders(pattern, { path: query });
+}
+function resolveRecordAddressPattern(query, lane) {
+  if (typeof query !== "string" || query.length === 0) return null;
+  const pattern = readPattern(lane, "record");
+  if (!pattern) return null;
+  if (!pattern.includes(PARAM_SLOT)) {
+    warnOnce(
+      `record:${pattern}`,
+      `config.records.record carries no ${PARAM_SLOT} placeholder, so every record would resolve to the same address. Ignoring it and reading the per-record file instead.`
+    );
+    return null;
+  }
+  return substitutePlaceholders(pattern, { path: query });
+}
+function localizeConfig(cfg, locale, defaultLocale) {
+  if (!cfg.path) return cfg;
+  if (!locale || locale === defaultLocale) return cfg;
+  if (!isDataUrl(cfg.path)) return cfg;
+  return { ...cfg, path: `/${locale}${cfg.path}` };
+}
+function applyDeferredDetail(cfg, queries, records) {
+  if (cfg.detail !== void 0) return cfg;
+  if (cfg.endpoint) {
+    const recordPattern = resolveRecordAddressPattern(cfg.query, records);
+    if (recordPattern) return { ...cfg, detail: recordPattern };
+  }
+  const queryName = cfg.query || bindingKey(cfg);
+  if (!queryName || !queries) return cfg;
+  const collConfig = queries[queryName];
+  if (!collConfig || typeof collConfig !== "object") return cfg;
+  const deferred = Array.isArray(collConfig.deferred) ? collConfig.deferred : null;
+  if (!deferred || deferred.length === 0) return cfg;
+  const pattern = typeof collConfig.detailUrl === "string" ? collConfig.detailUrl : recordDataUrl(queryName, "{slug}");
+  return { ...cfg, detail: pattern };
+}
+function resolveQuerySource(cfg, records) {
+  if (typeof cfg.query !== "string" || cfg.query.length === 0) return cfg;
+  const endpoint = resolveQueryAddress(cfg.query, records);
+  if (endpoint) {
+    const { path, url, ...rest } = cfg;
+    return { ...rest, endpoint };
+  }
+  return { ...cfg, path: queryDataUrl(cfg.query) };
+}
+function bindingKey(cfg) {
+  return cfg?.as;
+}
+function resolveFetchConfigs(sources, options = {}) {
+  const {
+    schemas = [],
+    locale = null,
+    defaultLocale = null,
+    queries = null,
+    records = null
+  } = options;
+  const configs = /* @__PURE__ */ new Map();
+  const collectAll = schemas.length === 0;
+  for (const source of sources) {
+    if (!source) continue;
+    const configList = Array.isArray(source) ? source : [source];
+    for (const cfg of configList) {
+      const key = bindingKey(cfg);
+      if (!key) continue;
+      if (configs.has(key)) continue;
+      if (!collectAll && !schemas.includes(key)) continue;
+      const sourced = resolveQuerySource(cfg, records);
+      const localized = localizeConfig(sourced, locale, defaultLocale);
+      configs.set(key, applyDeferredDetail(localized, queries, records));
+    }
+  }
+  return configs;
+}
+function deriveCacheKey(request) {
+  const { path, url, endpoint, transform } = request || {};
+  const as = request?.as;
+  const method = request?.method && request.method.toUpperCase() !== "GET" ? request.method.toUpperCase() : void 0;
+  const body = method === "POST" ? request?.body : void 0;
+  return JSON.stringify({ path, url, endpoint, as, transform, method, body });
+}
+function codeOf(entry) {
+  if (typeof entry === "string" && entry.trim() && entry.trim() !== "*") return entry.trim();
+  if (entry && typeof entry === "object" && typeof entry.code === "string" && entry.code.trim()) {
+    return entry.code.trim();
+  }
+  return null;
+}
+function normalizeLanguageList(value) {
+  if (!Array.isArray(value)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const codes = [];
+  for (const entry of value) {
+    const code = codeOf(entry);
+    if (!code || seen.has(code)) continue;
+    seen.add(code);
+    codes.push(code);
+  }
+  return codes;
+}
+function resolveDefaultLocale(config = {}) {
+  if (typeof config?.defaultLanguage === "string" && config.defaultLanguage.trim()) {
+    return config.defaultLanguage.trim();
+  }
+  return normalizeLanguageList(config?.languages)[0] || "en";
+}
+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$1(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$1(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(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(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 });
+}
 export {
   applyDefaults,
   applySchemas,
   classifyRenderError,
   escapeHtml,
+  executeFetchConfigs,
+  findPageForRoute,
   generate404Html,
   getComponentDefaults,
   getComponentMeta,
@@ -866,6 +1360,7 @@ export {
   initPrerenderForLocale,
   injectPageContent,
   prefetchIcons,
+  prefetchPageData,
   prepareProps,
   renderAppearanceBootScript,
   renderBackground,
@@ -874,6 +1369,7 @@ export {
   renderLayout,
   renderPage,
   resolvePage,
+  resolvePageFetchConfigs,
   sliceContentForLocale
 };
 //# sourceMappingURL=ssr.js.map