@uniweb/build 0.14.25 → 0.14.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.14.25",
+  "version": "0.14.27",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -59,12 +59,12 @@
     "js-yaml": "^4.1.0",
     "sharp": "^0.33.2",
     "yaml": "^2.5.0",
-    "@uniweb/theming": "0.1.6",
+    "@uniweb/theming": "0.1.7",
     "@uniweb/content-writer": "0.2.6"
   },
   "optionalDependencies": {
     "@uniweb/content-reader": "1.1.12",
-    "@uniweb/runtime": "0.8.23",
+    "@uniweb/runtime": "0.8.25",
     "@uniweb/schemas": "0.2.4"
   },
   "peerDependencies": {
@@ -74,7 +74,7 @@
     "@tailwindcss/vite": "^4.0.0",
     "@vitejs/plugin-react": "^4.0.0 || ^5.0.0",
     "vite-plugin-svgr": "^4.0.0",
-    "@uniweb/core": "0.7.17"
+    "@uniweb/core": "0.7.19"
   },
   "peerDependenciesMeta": {
     "vite": {

package/src/prerender.js

@@ -96,7 +96,7 @@ async function executeAllFetches(siteContent, siteDir, onProgress, localeInfo) {
     onProgress(`  Fetching site data: ${cfg.path || cfg.url}`)
     const result = await executeFetch(cfg, opts)
     if (result.data && !result.error) {
-      fetchedData.push({ config: cfg, data: result.data })
+      fetchedData.push({ config: cfg, data: result.data, _scope: '__site__' })
     }
   }
 
@@ -112,7 +112,7 @@ async function executeAllFetches(siteContent, siteDir, onProgress, localeInfo) {
       onProgress(`  Fetching page data for ${page.route}: ${cfg.path || cfg.url}`)
       const result = await executeFetch(cfg, opts)
       if (result.data && !result.error) {
-        fetchedData.push({ config: cfg, data: result.data })
+        fetchedData.push({ config: cfg, data: result.data, _scope: page.route })
         // Store for dynamic route expansion
         pageFetchedData.set(page.route, {
           schema: pageFetch.schema,
@@ -212,13 +212,19 @@ export function expandDynamicPages(pages, pageFetchedData, onProgress) {
       concretePage.paramName = undefined
       concretePage.parentSchema = undefined
 
-      // Store the dynamic route context for runtime data resolution
+      // Store the dynamic route context for runtime data resolution. Only the
+      // keys the runtime actually uses — the entity cascade re-finds the record
+      // from the fetched collection by paramName/paramValue/schema. The record
+      // (`currentItem`) and the full sibling list (`allItems`) are deliberately
+      // NOT baked in: nothing reads them (the documented dynamicContext shape is
+      // { paramName, paramValue, schema }; the record is delivered via
+      // content.data and siblings via `fetch: { refine: true, detail: false }`),
+      // and embedding `allItems` duplicated the whole collection onto every
+      // prerendered page in split mode.
       concretePage.dynamicContext = {
         paramName,
         paramValue,
         schema,           // Plural: 'articles'
-        currentItem: item,    // The item for this specific route
-        allItems: items,      // All items from parent
       }
 
       // Use item data for page metadata if available
@@ -323,6 +329,42 @@ async function discoverLocaleContents(distDir, defaultContent) {
   return locales
 }
 
+/**
+ * Strip the internal `_scope` tag off a fetchedData entry, leaving the clean
+ * `{ config, data }` shape the runtime's hydrateDataStore expects.
+ */
+function stripFetchScope(entry) {
+  const { _scope, ...clean } = entry
+  return clean
+}
+
+/**
+ * Scope `fetchedData` for a single page's inline __SITE_CONTENT__.
+ *
+ * Every fetchedData entry is tagged (in executeAllFetches) with `_scope`:
+ * '__site__' for a site-level fetch, or the owning page's route for a
+ * page-level fetch. A page's first render only ever reads the cascade
+ * block → page → page.parent → site (see @uniweb/core EntityStore), so in
+ * split-content mode we embed just the entries that cascade can reach —
+ * site-level plus the page's own route and its parent's route (`scopeRoutes`).
+ * Other pages' data, and dynamic detail data reached only by client-side
+ * navigation, is fetched on demand and must not ride in every page's payload.
+ *
+ * `scopeRoutes == null` means "don't scope" (non-split mode, or the SPA
+ * fallback): keep every entry. Either way the internal `_scope` tag is stripped.
+ *
+ * @param {Array<{config: Object, data: any, _scope?: string}>} fetchedData
+ * @param {Set<string>|null} scopeRoutes - Routes whose entries to keep, or null.
+ * @returns {Array<{config: Object, data: any}>}
+ */
+export function scopeFetchedData(fetchedData, scopeRoutes) {
+  if (!Array.isArray(fetchedData)) return fetchedData
+  if (!scopeRoutes) return fetchedData.map(stripFetchScope)
+  return fetchedData
+    .filter((e) => e._scope === '__site__' || scopeRoutes.has(e._scope))
+    .map(stripFetchScope)
+}
+
 /**
  * Inject build-specific data into HTML (theme CSS, __SITE_CONTENT__, icon cache).
  * Called after the shared injectPageContent for build-specific additions.
@@ -334,7 +376,7 @@ async function discoverLocaleContents(distDir, defaultContent) {
  * @param {string|null} [options.currentRoute=null] - Route of the page this HTML is for
  * @returns {string} HTML with build-specific data injected
  */
-function injectBuildData(html, siteContent, { splitContent = false, currentRoute = null } = {}) {
+function injectBuildData(html, siteContent, { splitContent = false, currentRoute = null, scopeRoutes = null } = {}) {
   let result = html
 
   // Inject theme CSS if not already present
@@ -367,6 +409,16 @@ function injectBuildData(html, siteContent, { splitContent = false, currentRoute
     }
   }
 
+  // Scope fetched (collection / API) data to this page's cascade in split mode,
+  // so a page never carries other pages' collections. Non-split keeps it all
+  // (single-file inline). Either way the internal `_scope` tag is stripped.
+  if (Array.isArray(contentForJson.fetchedData)) {
+    contentForJson = {
+      ...contentForJson,
+      fetchedData: scopeFetchedData(contentForJson.fetchedData, splitContent ? scopeRoutes : null),
+    }
+  }
+
   const contentScript = `<script id="__SITE_CONTENT__" type="application/json">${JSON.stringify(contentForJson).replace(/</g, '\\u003c')}</script>`
   if (result.includes('__SITE_CONTENT__')) {
     // Replace existing site content with updated version (includes expanded dynamic routes)
@@ -667,10 +719,14 @@ export async function prerenderSite(siteDir, options = {}) {
         sectionOverrideCSS: result.sectionOverrideCSS,
       })
 
-      // Build-specific: theme CSS, __SITE_CONTENT__, icon cache
+      // Build-specific: theme CSS, __SITE_CONTENT__, icon cache.
+      // scopeRoutes mirrors the runtime data cascade (page → page.parent → site)
+      // so split-mode pages embed only the collection data their first render reads.
+      const scopeRoutes = new Set([page.route, page.parent?.route].filter(Boolean))
       html = injectBuildData(html, siteContent, {
         splitContent,
         currentRoute: page.route,
+        scopeRoutes,
       })
 
       // Output to the locale-prefixed route
@@ -686,6 +742,7 @@ export async function prerenderSite(siteDir, options = {}) {
     const fallbackBaseHtml = injectBuildData(htmlShell, siteContent, {
       splitContent,
       currentRoute: null,  // 404 has no current page — manifest only
+      scopeRoutes: new Set(),  // SPA fallback carries site-level fetched data only
     })
     const { html: notFoundHtml, hasNotFoundPage } = generate404Html({
       baseHtml: fallbackBaseHtml,
@@ -710,6 +767,11 @@ export async function prerenderSite(siteDir, options = {}) {
           return metadata
         })
       }
+      // The manifest is a single (non-per-page) file, so it keeps all fetched
+      // data — but the internal `_scope` tag must never leak into it.
+      if (Array.isArray(manifest.fetchedData)) {
+        manifest.fetchedData = manifest.fetchedData.map(stripFetchScope)
+      }
       await writeFile(localeContentPath, JSON.stringify(manifest))
       onProgress('Rewrote site-content.json as lightweight manifest')
     }

package/src/site/plugin.js

@@ -74,8 +74,45 @@ function resolveFaviconHref(configFavicon, publicDir, basePath) {
 }
 
 /**
- * Execute all fetches for site content (used in dev mode)
- * Collects fetchedData for DataStore pre-population at runtime
+ * Should this fetch config be pre-executed at build time and embedded into the
+ * dev boot payload, or left for the runtime to fetch live?
+ *
+ * Dev has no prerender step, so there is no server-rendered HTML to hydrate and
+ * nothing to gain from embedding fetched data — while embedding it *costs*
+ * freshness: the boot payload is a one-time snapshot, so editing a local
+ * collection regenerates `/data/*.json` but the runtime keeps reading the stale
+ * embed until the dev server is restarted.
+ *
+ * So in dev we embed only what the browser genuinely cannot fetch itself:
+ *   - Local `path:` sources (file-based collections → `/data/*.json`) are served
+ *     by Vite and always browser-reachable, so we never embed them — the runtime
+ *     fetches them live and picks up edits on reload. This also gives local
+ *     collections true parity with a real backend fetcher.
+ *   - `prerender: false` opts a source out of build-time fetching by definition.
+ *   - Remote `url:` sources with `prerender !== false` may target a
+ *     build-time-only endpoint (server-side auth, no CORS), so we keep
+ *     pre-fetching and embedding them, mirroring what prod prerender does.
+ *
+ * Prod is unaffected: prerender still embeds fetched data for flash-free SSG
+ * hydration (see build/src/prerender.js executeAllFetches / injectBuildData).
+ *
+ * @param {Object|null} cfg - A normalized fetch config (parseFetchConfig output)
+ * @returns {boolean}
+ */
+export function shouldPrefetchInDev(cfg) {
+  if (!cfg) return false
+  if (!cfg.path && !cfg.url) return false // refinement / nothing to fetch
+  if (cfg.prerender === false) return false // author opted into runtime fetch
+  if (cfg.path && !cfg.url) return false // local file — runtime fetches it live
+  return true // remote build-time fetch — keep embedding in dev
+}
+
+/**
+ * Execute the dev fetches that should be embedded (see shouldPrefetchInDev) and
+ * collect them as `fetchedData` for DataStore pre-population. Local file-based
+ * collections and `prerender: false` sources are intentionally skipped so the
+ * runtime fetches them live — keeping the dev payload free of dynamic data and
+ * ensuring edits to `/data/*.json` show up on reload without a dev restart.
  *
  * @param {Object} siteContent - The collected site content
  * @param {string} siteDir - Path to site directory
@@ -86,7 +123,7 @@ async function executeDevFetches(siteContent, siteDir) {
 
   // Site-level fetch
   const siteFetch = siteContent.config?.fetch
-  if (siteFetch) {
+  if (shouldPrefetchInDev(siteFetch)) {
     const result = await executeFetch(siteFetch, fetchOptions)
     if (result.data && !result.error) {
       fetchedData.push({ config: siteFetch, data: result.data })
@@ -97,7 +134,7 @@ async function executeDevFetches(siteContent, siteDir) {
   for (const page of siteContent.pages || []) {
     // Page-level fetch
     const pageFetch = page.fetch
-    if (pageFetch) {
+    if (shouldPrefetchInDev(pageFetch)) {
       const result = await executeFetch(pageFetch, fetchOptions)
       if (result.data && !result.error) {
         fetchedData.push({ config: pageFetch, data: result.data })
@@ -125,7 +162,7 @@ async function processDevSectionFetches(sections, fetchOptions) {
   for (const section of sections) {
     // Execute section-level fetch
     const sectionFetch = section.fetch
-    if (sectionFetch) {
+    if (shouldPrefetchInDev(sectionFetch)) {
       const result = await executeFetch(sectionFetch, fetchOptions)
       if (result.data && !result.error) {
         // Merge fetched data into section's parsedContent (not cascadedData)