@uniweb/runtime 1.5.4 → 1.5.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/runtime",
-  "version": "1.5.4",
+  "version": "1.5.6",
   "description": "Minimal runtime for loading Uniweb foundations",
   "type": "module",
   "exports": {
@@ -36,7 +36,7 @@
     "node": ">=22.12"
   },
   "dependencies": {
-    "@uniweb/core": "~1.6.9",
+    "@uniweb/core": "~1.6.11",
     "@uniweb/theming": "~1.3.2"
   },
   "devDependencies": {
@@ -44,7 +44,7 @@
     "esbuild": "^0.21.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.27.0 || ^0.28.0",
     "vite": "^7.3.1",
     "vitest": "^4.1.7",
-    "@uniweb/build": "1.19.0"
+    "@uniweb/build": "1.20.4"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/page-renderer.js

@@ -39,6 +39,7 @@ import { hydrateDataStore } from './wire-foundation.js'
 import { loadPageData } from './load-page-data.js'
 import { requireTransport } from './require-transport.js'
 import { whileReadingIcons } from './page-icons.js'
+import { sectionRecords } from './section-records.js'
 
 /**
  * A renderer bound to one initialized Website and one shell.
@@ -81,8 +82,15 @@ export function createPageRenderer({ website, shell }) {
    *   parametric pages made from them (`Website#forgetData`), and files these, all in this
    *   synchronous call, so a Website reused across requests renders each against its own and
    *   no other request runs in between. Absent, the render reads whatever the store holds.
+   * @param {boolean} [options.sectionData] - also say what the page's Markdown carries:
+   *   `sections`, the records each section showed, and on a record page `record`, its own record as
+   *   this render read it. Hand both to `renderPageMarkdown(page, { record, sections })`
+   *   (`@uniweb/projections`). Read from the store this render read, after its HTML
+   *   (`section-records.js`), so a render that does not ask does no more work than before.
    * @returns {{ outcome: 'rendered'|'notFound'|'failed', html: string|null,
-   *   page: Object|null, error: {type: string, message: string}|null }}
+   *   page: Object|null, error: {type: string, message: string}|null,
+   *   sections?: Array<{ id: string, data: Object }>, record?: Object|null }} `sections` when asked,
+   *   on a page with `html`; `record` beside it on a record page, null when its route names none
    *   `notFound` means the URL names nothing, and `html` says whether there is a page to
    *   send for it. Send `html` with your not-found status when it is set, and the shell
    *   when it is not:
@@ -95,7 +103,7 @@ export function createPageRenderer({ website, shell }) {
    *   - `page` set, `html: null`, `error` set — that page broke while rendering; `error`
    *     says what broke.
    */
-  function render(target, { inject = {}, fetchedData } = {}) {
+  function render(target, { inject = {}, fetchedData, sectionData = false } = {}) {
     if (fetchedData !== undefined && !Array.isArray(fetchedData)) {
       throw new Error('createPageRenderer: `fetchedData` must be the array of entries the page carries')
     }
@@ -181,7 +189,14 @@ export function createPageRenderer({ website, shell }) {
       sectionOverrideCSS: result.sectionOverrideCSS,
       icons,
     })
-    return { outcome: missing ? 'notFound' : 'rendered', html, page, error: null }
+    const rendered = { outcome: missing ? 'notFound' : 'rendered', html, page, error: null }
+    // In this same synchronous call, so the store holds this page's answers and no other request's.
+    if (sectionData) {
+      const shown = sectionRecords(page)
+      rendered.sections = shown.sections
+      if (shown.record !== undefined) rendered.record = shown.record
+    }
+    return rendered
   }
 
   return { website, render, failingSection: (page, message) => failingSectionOf(page, message) }

package/src/prepare-props.js

@@ -142,7 +142,21 @@ export function applyDefaults(params, defaults) {
  * section received every fetch that reached it and every tagged block it had.
  */
 function assembleData(block, meta, entityData) {
-  const declared = block.website?.declaredKeys ? block.website.declaredKeys(meta) : []
+  const declared = declaredOf(block, meta)
+  const data = collectDeclared(block, declared, entityData)
+  // What the section holds and this leaves out — the keys the dev warning reports.
+  warnUndeclaredBlocks(block, Object.keys(block.heldData || {}).filter((key) => !Object.hasOwn(data, key)))
+  block.parsedContent.data = data
+  return declared
+}
+
+/** The keys a block's component receives: its own `data:`, then its foundation's. */
+function declaredOf(block, meta) {
+  return block.website?.declaredKeys ? block.website.declaredKeys(meta) : []
+}
+
+/** Each declared key's value, by the order `assembleData` states: held, delivered, else `null`. */
+function collectDeclared(block, declared, entityData) {
   const held = block.heldData || {}
   const data = {}
   for (const [key] of declared) {
@@ -150,10 +164,27 @@ function assembleData(block, meta, entityData) {
     else if (entityData && entityData[key] !== undefined) data[key] = entityData[key]
     else data[key] = null
   }
-  // What the section holds and this leaves out — the keys the dev warning reports.
-  warnUndeclaredBlocks(block, Object.keys(held).filter((key) => !Object.hasOwn(data, key)))
-  block.parsedContent.data = data
-  return declared
+  return data
+}
+
+/**
+ * ⭐ WHAT A SECTION'S COMPONENT RECEIVES UNDER THE KEYS IT DECLARES, BEFORE ANY FOUNDATION HANDLER —
+ * `content.data` as `prepareProps` assembles it, its records linked (`linkOwnRecords`) and a
+ * `single` key holding one, worked out without touching the block. For a caller reporting what a
+ * section received, after its render: a page's Markdown (`section-records.js`). ⛔ Never for
+ * rendering, which is `prepareProps`'.
+ *
+ * @param {Object} block
+ * @param {Object|null} meta - its component's runtime meta
+ * @param {Object|null} [entityData] - what the entity store delivered for it, as the render read it
+ * @returns {{ declared: Array, data: Object }}
+ */
+export function receivedData(block, meta, entityData = null) {
+  const declared = declaredOf(block, meta)
+  // A stand-in carries the data through the linking, so the block's own is left as its render left it.
+  const probe = { parsedContent: { data: collectDeclared(block, declared, entityData) }, fetch: block.fetch, website: block.website }
+  block.website?.entityStore?.linkOwnRecords?.(probe)
+  return { declared, data: oneRecordEach(probe.parsedContent.data, declared) }
 }
 
 /**
@@ -168,14 +199,18 @@ function assembleData(block, meta, entityData) {
  * object is replaced, never written into.
  */
 function holdOneRecord(block, declared) {
-  const data = block.parsedContent.data
+  block.parsedContent.data = oneRecordEach(block.parsedContent.data, declared)
+}
+
+/** `data` with each `single` key's list cut to its first record, or `data` itself when none is. */
+function oneRecordEach(data, declared) {
   let out = null
   for (const [key, , , single] of declared) {
     if (single !== true || !Array.isArray(data?.[key])) continue
     out = out || { ...data }
     out[key] = data[key][0] ?? null
   }
-  if (out) block.parsedContent.data = out
+  return out || data
 }
 
 /**

package/src/section-records.js

@@ -0,0 +1,160 @@
+/**
+ * WHAT A PAGE'S SECTIONS SHOWED FROM RECORDS — for the page's Markdown, never for its render.
+ *
+ * ⭐ A page's Markdown (`renderPageMarkdown`, `@uniweb/projections`) carries, after each section, the
+ * records that section shows. Which records those are only the render knows: the keys its component
+ * declares, each filled by the one rule (`@uniweb/core/page-data`), as briefs or whole, one record or
+ * the set, with this page's record or without it. A rule over the site's content alone would get each
+ * of those wrong, and a host's prefetch retired that rule for the same reasons (`load-page-data.js`).
+ * So they are read back from the store the render has just read, by the reading it filled each section
+ * by, after the HTML: in L2, with no twin to keep (L3 does not change), and nowhere in the browser's
+ * bundle, since only `page-renderer.js` asks and only the SSR entry exports it.
+ *
+ * A section's records:
+ *
+ *   - **The keys its component declares** in its own `data:`. Not its foundation's (`main.js` `data:`),
+ *     which reach every section, since a foundation's handlers run for every section, and which of
+ *     them draws one is the foundation's business.
+ *   - **As delivered**, before any foundation handler (`receivedData`, `./prepare-props.js`): the
+ *     site's records, never a foundation's derivation of them.
+ *   - **Named by the site's word:** the fetch's `as`, which is its query's name unless the site gives
+ *     another. A component's key is the foundation's word, and a fetch can fill a key of another name
+ *     that has its schema (`fillDeclaredKeys`). A held answer is under its fetch's `as` already. Two
+ *     keys of one section filled under one `as` with different records: the second goes by its key.
+ *   - **Left out:** a key the section holds as a tagged block in its own content (` ```yaml:tag `, or
+ *     a concept block), which the page's Markdown already shows as it was written; a record page's
+ *     own record (a key whose fetch uses this page's record, `current: only`), which its Markdown
+ *     writes once, as the page's, from `record` (`pageRecordOf`); and a key with no value, `null` —
+ *     nothing fills it, or its fetch failed, never ran or is still out.
+ *   - **Whose:** each body section and its child sections, under its own id, and the insets in a
+ *     section, under the id of the section they sit in, since a page's Markdown has no place of their
+ *     own for them. Not the layout's areas, whose own content the page's Markdown doesn't carry either.
+ *
+ * @module
+ */
+import { sectionDomId } from '@uniweb/core/section-id'
+import { declaredKeys } from '@uniweb/core/data-keys'
+import { blockFillsOf, blockRouteQuery, fillIsPageRecord, heldPageRecord } from '@uniweb/core/page-data'
+import { getComponentMeta, receivedData } from './prepare-props.js'
+
+/**
+ * The records each of a page's sections showed, and a record page's own record, read after the
+ * page's render: what its Markdown carries (`renderPageMarkdown(page, { record, sections })`).
+ *
+ * @param {Object} page - the Page just rendered, its Website the one `globalThis.uniweb` names
+ * @returns {{ sections: Array<{ id: string, data: Object }>, record: Object|null|undefined }}
+ *   `sections` in page order, one entry per section, child section or inset that showed any, `id`
+ *   the section's DOM id (`sectionDomId`) and `data` its records by name. `record` a record page's
+ *   own (`pageRecordOf`): null when its route names none, undefined off a record page
+ */
+export function sectionRecords(page) {
+  const sections = []
+  // The page's own record as its sections received it, which `sections` leaves out.
+  const shown = []
+  for (const block of page?.getBodyBlocks?.() ?? []) visit(block, sectionDomId(block), sections, shown)
+  return { sections, record: pageRecordOf(page, shown) }
+}
+
+function visit(block, id, sections, shown) {
+  if (!block) return
+  const data = recordsOf(block, shown)
+  if (data) sections.push({ id, data })
+  for (const inset of block.insets || []) visit(inset, id, sections, shown)
+  for (const child of block.childBlocks || []) visit(child, sectionDomId(child), sections, shown)
+}
+
+/**
+ * ⭐ A RECORD PAGE'S OWN RECORD, AS ITS RENDER READ IT — the most of it the page held, so its
+ * Markdown carries what its sections drew: whole when a section received it whole, or when the
+ * record index holds it whole; else as a section received it; else the answer the page's own
+ * question got (`heldPageRecord`, `@uniweb/core/page-data`), which names the page and says whether
+ * it exists.
+ *
+ * @param {Object} page
+ * @param {Array<{ value: *, whole: boolean }>} shown
+ * @returns {Object|null|undefined}
+ */
+function pageRecordOf(page, shown) {
+  if (!page?.dynamicContext) return undefined
+  const one = (value) => (Array.isArray(value) ? (value[0] ?? null) : value)
+  const whole = shown.find((s) => s.whole && one(s.value))
+  if (whole) return one(whole.value)
+  const website = page.website
+  const fetcher = website?.fetcher
+  const own = heldPageRecord(page, {
+    website,
+    peek: (request) => fetcher?.peek?.(request, { website, page, block: null }),
+    peekRecord: (id) => fetcher?.peekRecord?.(id),
+  })
+  const seen = shown.map((s) => one(s.value)).find(Boolean) ?? null
+  const id = (own ?? seen)?.$uuid
+  const held = typeof id === 'string' && id ? fetcher?.peekRecord?.(id) : null
+  if (held?.whole === true && held.record) return held.record
+  return seen ?? own
+}
+
+/** One block's records by name, or null when it showed none. */
+function recordsOf(block, shown) {
+  // A type the foundation doesn't have renders as an error box, and its render asks for no data.
+  if (!globalThis.uniweb?.getComponent?.(block.type)) return null
+  const meta = getComponentMeta(block.type)
+  const own = declaredKeys(meta?.data)
+  if (own.length === 0) return null
+
+  // The resolve the render just made, from the same store: `renderBlock` (`ssr-renderer.js`).
+  const resolved = block.website?.entityStore?.resolve(block, meta)
+  const { data } = receivedData(block, meta, resolved?.status === 'ready' ? resolved.data : null)
+
+  const held = block.heldData || {}
+  let fills = null
+  let route = null
+  let tagged = null
+  const out = {}
+  for (const [key] of own) {
+    const value = data[key]
+    if (value === undefined || value === null) continue
+    let name
+    if (held[key] !== undefined) {
+      tagged ??= taggedKeys(block)
+      if (tagged.has(key)) continue
+      // An answer a static build prerendered into the section, under its fetch's `as`.
+      name = key
+    } else {
+      if (!fills) {
+        route = blockRouteQuery(block)
+        fills = blockFillsOf(block, meta, route)
+      }
+      const fill = fills.get(key)
+      const cfg = fill?.cfg
+      if (!cfg?.as) continue
+      if (fillIsPageRecord(block, cfg, route)) {
+        shown.push({ value, whole: fill.whole === true })
+        continue
+      }
+      name = cfg.as
+    }
+    if (Object.hasOwn(out, name) && !sameValue(out[name], value)) name = key
+    if (Object.hasOwn(out, name) && !sameValue(out[name], value)) continue
+    out[name] = value
+  }
+  return Object.keys(out).length ? out : null
+}
+
+/**
+ * The keys a section's own content holds as tagged blocks: its content parsed alone, without the
+ * answers a build put beside it (`Block`'s constructor merges the two). `parseContent` is pure, and
+ * this runs only for a section holding a declared key.
+ */
+function taggedKeys(block) {
+  const parsed = typeof block.parseContent === 'function' && block.rawContent ? block.parseContent(block.rawContent) : null
+  return new Set(Object.keys(parsed?.data || {}))
+}
+
+function sameValue(a, b) {
+  if (a === b) return true
+  try {
+    return JSON.stringify(a) === JSON.stringify(b)
+  } catch {
+    return false
+  }
+}