@uniweb/runtime 1.5.5 → 1.5.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/runtime",
-  "version": "1.5.5",
+  "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.10",
+    "@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.20.3"
+    "@uniweb/build": "1.20.4"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/page-renderer.js

@@ -82,13 +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 which records each section showed, for the
-   *   page's Markdown: `sections`, which `renderPageMarkdown(page, { sections })`
-   *   (`@uniweb/projections`) writes after each section. 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.
+   * @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,
-   *   sections?: Array<{ id: string, data: Object }> }} `sections` when asked, on a page with `html`
+   *   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:
@@ -189,7 +191,11 @@ export function createPageRenderer({ website, shell }) {
     })
     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) rendered.sections = sectionRecords(page)
+    if (sectionData) {
+      const shown = sectionRecords(page)
+      rendered.sections = shown.sections
+      if (shown.record !== undefined) rendered.record = shown.record
+    }
     return rendered
   }
 

package/src/section-records.js

@@ -24,7 +24,7 @@
  *   - **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 (`renderPageMarkdown`'s `record`); and a key with no value, `null` —
+ *     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
@@ -34,32 +34,67 @@
  */
 import { sectionDomId } from '@uniweb/core/section-id'
 import { declaredKeys } from '@uniweb/core/data-keys'
-import { blockFillsOf, blockRouteQuery, fillIsPageRecord } from '@uniweb/core/page-data'
+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, read after the page's render.
+ * 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 {Array<{ id: string, data: Object }>} 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
+ * @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 out = []
-  for (const block of page?.getBodyBlocks?.() ?? []) visit(block, sectionDomId(block), out)
-  return out
+  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, out) {
+function visit(block, id, sections, shown) {
   if (!block) return
-  const data = recordsOf(block)
-  if (data) out.push({ id, data })
-  for (const inset of block.insets || []) visit(inset, id, out)
-  for (const child of block.childBlocks || []) visit(child, sectionDomId(child), out)
+  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) {
+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)
@@ -89,8 +124,13 @@ function recordsOf(block) {
         route = blockRouteQuery(block)
         fills = blockFillsOf(block, meta, route)
       }
-      const cfg = fills.get(key)?.cfg
-      if (!cfg?.as || fillIsPageRecord(block, cfg, route)) continue
+      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