@uniweb/build 0.47.2 → 0.48.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.47.2",
+  "version": "0.48.0",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -57,15 +57,15 @@
     "js-yaml": "^4.1.0",
     "sharp": "^0.35.3",
     "yaml": "^2.5.0",
-    "@uniweb/projections": "^0.6.2",
-    "@uniweb/content-writer": "^0.3.4",
     "@uniweb/content-reader": "^1.2.4",
     "@uniweb/schemas": "^0.2.13",
+    "@uniweb/projections": "^0.7.0",
+    "@uniweb/theming": "^0.1.15",
     "@uniweb/semantic-parser": "^1.4.0",
-    "@uniweb/theming": "^0.1.15"
+    "@uniweb/content-writer": "^0.3.4"
   },
   "optionalDependencies": {
-    "@uniweb/runtime": "^0.22.0"
+    "@uniweb/runtime": "^0.23.0"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",
@@ -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.26.2"
+    "@uniweb/core": "^0.27.0"
   },
   "peerDependenciesMeta": {
     "vite": {

package/src/prerender.js

@@ -15,8 +15,8 @@ import {
   resolveDefaultLocale,
   resolveFetchConfigs,
   joinPathCapture,
-  routeQuery,
-  sectionFetches,
+  pageRouteQuery,
+  routeSelection,
   routeParamValues,
   routeParamName,
   routeBinding,
@@ -128,17 +128,55 @@ export async function executeAllFetches(siteContent, siteDir, onProgress, locale
   // What each level fetched, by binding key — what `expandDynamicPages` iterates.
   const fetched = { site: new Map(), pages: new Map(), sections: new Map() }
 
+  /**
+   * Read one resolved config ONCE, as two things: the records it selects, uncut
+   * (`routeSelection`), and the view it delivers — the same records cut by its
+   * `limit`. ⭐ The view is what a page renders and hydrates; the selection is what
+   * a parametric page expands over, because a `limit` is how many a list shows,
+   * never which records have a page (ruled 2026-09-13 [Diego]). ⛔ Until then the
+   * expansion read the cut list, so a query's `limit: 2` made two detail pages of
+   * five. Null when the read failed.
+   */
+  const read = async (cfg, oneFetch) => {
+    const result = await executeFetch(routeSelection(cfg), optionsFor(cfg, oneFetch))
+    if (!result.data || result.error) return null
+    const selection = result.data
+    const view = Array.isArray(selection) && typeof cfg.limit === 'number' && cfg.limit > 0
+      ? selection.slice(0, cfg.limit)
+      : selection
+    return { selection, view }
+  }
+
+  /**
+   * The first binding of a key at one level is the one every lane uses
+   * (`resolveFetchConfigs`); a later one under the same key is ignored — and the
+   * parser has said so (`warnDuplicateBindings`). Counted BEFORE `prerender: false`
+   * is honoured, so a deferred first binding is not replaced by a baked second.
+   */
+  const firstOfKey = () => {
+    const seen = new Set()
+    return (as) => {
+      if (seen.has(as)) return false
+      seen.add(as)
+      return true
+    }
+  }
+
   // 1. Site-level fetch. ⛔ `toFetchList` rather than a property read: a `fetch:`
   // or `query:` LIST parses to an array, and `siteFetch.prerender` on one is
   // `undefined` — which passes the `!== false` test and then fetches nothing.
+  const firstSite = firstOfKey()
   for (const oneFetch of toFetchList(siteContent.config?.fetch)) {
-    if (oneFetch.prerender === false) continue
+    if (!firstSite(oneFetch.as)) continue
+    // ⭐ `prerender` is read off the RESOLVED config: an external query's binding is the
+    // browser's unless it says otherwise, which only the resolver knows.
     const cfg = resolveForBuild(oneFetch)
+    if (cfg.prerender === false) continue
     onProgress(`  Fetching site data: ${cfg.path || cfg.url}`)
-    const result = await executeFetch(cfg, optionsFor(cfg, oneFetch))
-    if (result.data && !result.error) {
-      fetchedData.push(entry(cfg, result.data, '__site__'))
-      if (!fetched.site.has(oneFetch.as)) fetched.site.set(oneFetch.as, result.data)
+    const got = await read(cfg, oneFetch)
+    if (got) {
+      fetchedData.push(entry(cfg, got.view, '__site__'))
+      fetched.site.set(oneFetch.as, got.selection)
     }
   }
 
@@ -157,19 +195,33 @@ export async function executeAllFetches(siteContent, siteDir, onProgress, locale
 
   for (const page of siteContent.pages || []) {
     // Page-level fetch — every declaration on the page.
+    const firstPage = firstOfKey()
     for (const oneFetch of toFetchList(page.fetch)) {
-      if (oneFetch.prerender === false) continue
+      if (!firstPage(oneFetch.as)) continue
       const cfg = resolveForBuild(oneFetch)
+      if (cfg.prerender === false) continue
       onProgress(`  Fetching page data for ${page.route}: ${cfg.path || cfg.url}`)
-      const result = await executeFetch(cfg, optionsFor(cfg, oneFetch))
-      if (result.data && !result.error) {
-        fetchedData.push(entry(cfg, result.data, page.route))
-        keep(fetched.pages, page.route, oneFetch.as, result.data)
+      const got = await read(cfg, oneFetch)
+      if (got) {
+        fetchedData.push(entry(cfg, got.view, page.route))
+        keep(fetched.pages, page.route, oneFetch.as, got.selection)
       }
     }
 
-    // Process section-level fetches (own fetch → parsedContent.data, not cascaded)
-    await processSectionFetches(page.sections, fetchOptions, onProgress, (as, data) => keep(fetched.sections, page.route, as, data))
+    // Section-level fetches — a section's own, into its `parsedContent.data`.
+    // ⛔ Not on a parametric page: there the sections are the runtime's to fill,
+    // because what one receives depends on the URL — the record under the route
+    // key, a view its route binds under any other. A list baked into the template
+    // was cloned into every expanded page and outranked both (measured 2026-09-13:
+    // `/blog/b` rendered all three records). Its views are read per expanded page
+    // instead (`readRouteBoundViews`).
+    await processSectionFetches(page.sections, {
+      resolve: resolveForBuild,
+      read,
+      onProgress,
+      record: (as, data) => keep(fetched.sections, page.route, as, data),
+      bake: !page.isDynamic,
+    })
   }
 
   /**
@@ -179,8 +231,8 @@ export async function executeAllFetches(siteContent, siteDir, onProgress, locale
    * browser's, as it is by default. Null when there is nothing to embed.
    */
   const bake = async (cfg) => {
-    if (cfg.prerender === false || typeof cfg.path !== 'string') return null
-    const options = isNonDefaultLocale && cfg.path.startsWith(`/${localeInfo.locale}/`) ? localizedFetchOptions : fetchOptions
+    if (cfg.prerender === false || (typeof cfg.path !== 'string' && typeof cfg.url !== 'string')) return null
+    const options = isNonDefaultLocale && typeof cfg.path === 'string' && cfg.path.startsWith(`/${localeInfo.locale}/`) ? localizedFetchOptions : fetchOptions
     const result = await executeFetch(cfg, options)
     if (!result.data || result.error) return null
     return { config: cfg, data: result.data, meta: { whole: cfg.whole } }
@@ -196,8 +248,9 @@ export async function executeAllFetches(siteContent, siteDir, onProgress, locale
  *
  * @param {Array} pages - Original pages array
  * @param {{ site?: Map, pages?: Map, sections?: Map }} fetched - what each level
- *   fetched, by binding key (`executeAllFetches`): `site` key → data; `pages` and
- *   `sections` route → (key → data)
+ *   selected, by binding key (`executeAllFetches`): `site` key → data; `pages` and
+ *   `sections` route → (key → data). Every record a binding selects, uncut by its
+ *   `limit` — a record past a list's count still gets its page
  * @param {function} onProgress - Progress callback
  * @param {Object} [stats] - receives `unrouted[route]`, the records with no param value
  * @param {Object} [options]
@@ -255,6 +308,10 @@ export function expandDynamicPages(pages, fetched, onProgress = () => {}, stats
   )
   const byRoute = new Map(pages.filter((p) => p?.route).map((p) => [p.route, p]))
   const has = (route) => byRoute.has(route)
+  const parentOf = (p) => {
+    const route = parentRouteOf(p.route, { declared: p.parent ?? null, has })
+    return route ? byRoute.get(route) : null
+  }
   const levels = {
     site: fetched?.site ?? new Map(),
     pages: fetched?.pages ?? new Map(),
@@ -268,19 +325,21 @@ export function expandDynamicPages(pages, fetched, onProgress = () => {}, stats
       continue
     }
 
-    // ⭐ THE ROUTE QUERY, by the rule every lane reads it with (`routeQuery`,
-    // `@uniweb/core/fetch-config`), off the parent every lane finds
-    // (`parentRouteOf`) — the page's own query, its parent's, the site's, or its
-    // sections' shared key. The records it expands over are that query's, at the
-    // level it came from. ⛔ Until 2026-09-11 this read `parentSchema` and always
-    // expanded over the parent route's first prerendered fetch.
-    const parentRoute = parentRouteOf(page.route, { declared: page.parent ?? null, has })
-    const parent = parentRoute ? byRoute.get(parentRoute) : null
-    const route = routeQuery({
-      page: page.fetch,
-      parent: parent?.fetch,
+    // ⭐ THE ROUTE QUERY, by the rule every lane reads it with (`pageRouteQuery`,
+    // `@uniweb/core/fetch-config`), off the parents every lane finds
+    // (`parentRouteOf`) — chosen at the page that captured the URL's variable: its
+    // own query, its parent's, the site's, or its sections' shared key. A page
+    // nested inside a parametric page expands over its capturing page's records.
+    // The records it expands over are that query's, at the level it came from.
+    // ⛔ Until 2026-09-11 this read `parentSchema` and always expanded over the
+    // parent route's first prerendered fetch; until 2026-09-13 a nested page looked
+    // one parent up, and expanded only when the `[slug]` page declared the query.
+    const route = pageRouteQuery(page, {
+      routeOf: (p) => p.route,
+      parentOf,
+      fetchOf: (p) => p.fetch,
+      sectionsOf: (p) => p.sections,
       site: siteFetch,
-      sections: sectionFetches(page.sections),
     })
 
     if (!route) {
@@ -289,10 +348,11 @@ export function expandDynamicPages(pages, fetched, onProgress = () => {}, stats
       continue
     }
 
-    const data = route.level === 'page' ? levels.pages.get(page.route)?.get(route.key)
-      : route.level === 'parent' ? levels.pages.get(parentRoute)?.get(route.key)
+    const capturing = route.capturing
+    const data = route.level === 'page' ? levels.pages.get(capturing.route)?.get(route.key)
+      : route.level === 'parent' ? levels.pages.get(parentOf(capturing)?.route)?.get(route.key)
         : route.level === 'site' ? levels.site.get(route.key)
-          : levels.sections.get(page.route)?.get(route.key)
+          : levels.sections.get(capturing.route)?.get(route.key)
 
     if (!Array.isArray(data)) {
       // No build-time data available (e.g., prerender: false on the route query).
@@ -382,7 +442,7 @@ export function expandDynamicPages(pages, fetched, onProgress = () => {}, stats
         // route. ⛔ No `schema`: the key the URL narrows is worked out where it is
         // read (deleted 2026-09-11). The record (`currentItem`) and the full sibling
         // list (`allItems`) are deliberately NOT baked in: the record is delivered
-        // via content.data and siblings via `fetch: { refine: true, detail: false }`,
+        // via content.data and the others via `fetch: { query, current: exclude }`,
         // and embedding `allItems` duplicated the whole collection onto every
         // prerendered page in split mode.
         const binding = routeBinding(page.route, catchAll ? { [catchAll]: capture } : { [paramName]: paramValue }, paramName)
@@ -417,28 +477,45 @@ export function expandDynamicPages(pages, fetched, onProgress = () => {}, stats
  * Process fetch configs for sections (and subsections recursively)
  * Section-level fetches merge data into parsedContent.data (not cascaded).
  *
+ * ⭐ RESOLVED BY THE RUNTIME'S RULE, as page fetches are (`resolve`). ⛔ Until
+ * 2026-09-13 a section's fetch was executed as authored: a non-default locale baked
+ * the default locale's records (measured: a French page's section held the English
+ * file), and a named query's routed clauses and, once its `limit` stopped being
+ * compiled into the file, its `limit` never applied.
+ *
  * @param {Array} sections - Array of section objects
- * @param {Object} fetchOptions - Options for executeFetch
- * @param {function} onProgress - Progress callback
+ * @param {Object} options
+ * @param {(cfg: Object) => Object} options.resolve - resolves one binding
+ * @param {(cfg: Object, authored: Object) => Promise<{selection: any, view: any}|null>} options.read
+ * @param {function} options.onProgress - Progress callback
+ * @param {(as: string, data: any) => void} [options.record] - receives each key's selection
+ * @param {boolean} [options.bake=true] - write the view into `parsedContent.data`
  */
-async function processSectionFetches(sections, fetchOptions, onProgress, record = null) {
+async function processSectionFetches(sections, { resolve, read, onProgress, record = null, bake = true }) {
   if (!sections || !Array.isArray(sections)) return
 
   for (const section of sections) {
     // Execute every section-level fetch. Each merges under its own key, so
     // several accumulate into one `parsedContent.data` — the same keyed map the
-    // runtime's EntityStore builds.
+    // runtime's EntityStore builds. ⛔ The FIRST binding of a key, as there: each
+    // replaced the last until 2026-09-13, so the build delivered the last binding
+    // and the runtime the first.
+    const seen = new Set()
     for (const sectionFetch of toFetchList(section.fetch)) {
-      if (sectionFetch.prerender === false) continue
-      onProgress(`  Fetching section data: ${sectionFetch.path || sectionFetch.url}`)
-      const result = await executeFetch(sectionFetch, fetchOptions)
-      if (result.data && !result.error) {
-        // What a section fetched, by key — the route query of a parametric page
-        // whose sections alone declare it (`routeQuery`).
-        if (record) record(sectionFetch.as, result.data)
+      if (seen.has(sectionFetch.as)) continue
+      seen.add(sectionFetch.as)
+      const cfg = resolve(sectionFetch)
+      if (cfg.prerender === false) continue
+      onProgress(`  Fetching section data: ${cfg.path || cfg.url}`)
+      const got = await read(cfg, sectionFetch)
+      if (!got) continue
+      // What a section fetched, by key — the route query of a parametric page
+      // whose sections alone declare it (`routeQuery`).
+      if (record) record(sectionFetch.as, got.selection)
+      if (bake) {
         section.parsedContent = mergeDataIntoContent(
           section.parsedContent || {},
-          result.data,
+          got.view,
           sectionFetch.as,
           sectionFetch.merge
         )
@@ -447,7 +524,7 @@ async function processSectionFetches(sections, fetchOptions, onProgress, record
 
     // Process subsections recursively
     if (section.subsections && section.subsections.length > 0) {
-      await processSectionFetches(section.subsections, fetchOptions, onProgress, record)
+      await processSectionFetches(section.subsections, { resolve, read, onProgress, record, bake })
     }
   }
 }