@uniweb/core 0.7.14 → 0.7.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/core",
-  "version": "0.7.14",
+  "version": "0.7.16",
   "description": "Core classes for the Uniweb platform - Uniweb, Website, Page, Block",
   "type": "module",
   "exports": {
@@ -30,7 +30,7 @@
     "vitest": "^4.1.7"
   },
   "dependencies": {
-    "@uniweb/theming": "0.1.4",
+    "@uniweb/theming": "0.1.5",
     "@uniweb/semantic-parser": "1.1.17"
   },
   "scripts": {

package/src/block.js

@@ -437,6 +437,15 @@ export default class Block {
    * @returns {Object|null} Next block's info or null
    */
   getNextBlockInfo() {
+    // Layout-area blocks (header/footer/panels) live on a shared, contentless
+    // area page — not the content page being rendered — so walking their own
+    // page's sequence never reaches the content. Their "next block" is the
+    // first content section of the active page (a header adapting to the
+    // section it floats over). Resolve against the active page instead.
+    const active = this.website?.activePage
+    if (active && active !== this.page) {
+      return active.getFirstBodyBlockInfo()
+    }
     const index = this.getIndex()
     if (index < 0 || !this.page) return null
     return this.page.getBlockInfo(index + 1)
@@ -448,6 +457,12 @@ export default class Block {
    * @returns {Object|null} Previous block's info or null
    */
   getPrevBlockInfo() {
+    // See getNextBlockInfo: from a shared layout-area block, "previous" is the
+    // last content section of the active page (e.g. a footer adapting to it).
+    const active = this.website?.activePage
+    if (active && active !== this.page) {
+      return active.getLastBodyBlockInfo()
+    }
     const index = this.getIndex()
     if (index <= 0 || !this.page) return null
     return this.page.getBlockInfo(index - 1)

package/src/entity-store.js

@@ -145,6 +145,28 @@ export default class EntityStore {
     return configs
   }
 
+  /**
+   * Post-process assembled collection data: for each fetch config that declares a
+   * `detailPage` page-ref, resolve it to a locale route template (O(1), via the
+   * Website's `_pageIdMap`) and inject a `route` on each record — so a dynamic-list
+   * card links to the collection's canonical detail page regardless of which page
+   * the list sits on. Runs after `data` is fully assembled, in BOTH the sync (peek)
+   * and async (fetch) paths. Replaces the old runtime `getCollectionDetailRoute`
+   * page-tree scan. A dangling `detailPage` (unresolvable ref) is a no-op — the
+   * component degrades gracefully; records with a baked `route` (file lane) are kept.
+   */
+  _applyDetailRoutes(data, configs, website) {
+    if (!data || !website?.resolveDetailPageTemplate) return
+    for (const [schema, cfg] of configs) {
+      if (!cfg.detailPage) continue
+      const items = data[schema]
+      if (!Array.isArray(items) || items.length === 0) continue
+      const template = website.resolveDetailPageTemplate(cfg.detailPage)
+      if (!template) continue
+      data[schema] = items.map((item) => addDetailRoute(item, template))
+    }
+  }
+
   /**
    * Auto-inject `detail:` on collection refs whose collection has
    * `deferred:` declared. The detail pattern points at the per-record
@@ -363,6 +385,7 @@ export default class EntityStore {
     }
 
     if (allCached) {
+      this._applyDetailRoutes(data, configs, block.website)
       return { status: 'ready', data }
     }
     return { status: 'pending', data: null }
@@ -465,6 +488,7 @@ export default class EntityStore {
     }
 
     if (parallelFetches.length > 0) await Promise.all(parallelFetches)
+    this._applyDetailRoutes(data, configs, block.website)
     return { data }
   }
 }
@@ -477,3 +501,27 @@ function peekArray(dispatcher, cfg, ctx) {
   if (!cached) return null
   return Array.isArray(cached.data) ? cached.data : null
 }
+
+/**
+ * Interpolate a record's fields into a detail-page route template to build its
+ * `route` (the canonical href for a card). `/blog/:slug` + `{ slug: 'a-post' }`
+ * → `/blog/a-post`. Returns a SHALLOW COPY with `route` added — never mutates the
+ * cached record (the same collection may back several sections with different
+ * detail pages). Idempotent + back-compat: a record that already carries a `route`
+ * (the file lane bakes one via collection-processor) is returned untouched. A
+ * `:param` with no matching record field → no `route` (graceful; degrades to the
+ * component's own fallback rather than emitting a broken href).
+ */
+function addDetailRoute(item, template) {
+  if (!item || typeof item !== 'object' || item.route !== undefined) return item
+  let missing = false
+  const route = template.replace(/:(\w+)/g, (_, name) => {
+    const value = item[name]
+    if (value == null) {
+      missing = true
+      return ''
+    }
+    return encodeURIComponent(String(value))
+  })
+  return missing ? item : { ...item, route }
+}

package/src/page.js

@@ -48,10 +48,16 @@ export default class Page {
     // Rewrite target (if set, this route is served by an external site)
     this.rewrite = pageData.rewrite || null
 
-    // Navigation visibility. `hidden` excludes the page from all nav; `hideIn` is a
-    // per-area denylist (layout-area names, e.g. ['header','footer']). The legacy
-    // hideInHeader/hideInFooter booleans are folded into hideIn and kept as derived
-    // accessors for back-compat.
+    // Two orthogonal visibility axes:
+    //  • `hidden` — REACHABILITY. When true the page is excluded from the published
+    //    site entirely (the build prunes it and its subtree); it survives only in
+    //    dev/authoring for preview. A hidden page is also, a fortiori, absent from
+    //    nav. This is NOT a nav-only flag.
+    //  • `hideIn` — NAV PLACEMENT. A per-area denylist (layout-area names, e.g.
+    //    ['header','footer']) applied while the page IS routed. The sentinel '*'
+    //    means "suppressed from every nav area" (still routed) — this is how a page
+    //    is kept reachable-but-out-of-all-menus. The legacy hideInHeader/hideInFooter
+    //    booleans fold into hideIn and are kept as derived accessors for back-compat.
     this.hidden = pageData.hidden || false
     this.hideIn = normalizeHideIn(pageData)
     this.hideInHeader = this.hideIn.includes('header')
@@ -265,6 +271,18 @@ export default class Page {
     return this.bodyBlocks?.[0]?.getBlockInfo() || null
   }
 
+  /**
+   * Get the last body block's info.
+   * Symmetric to getFirstBodyBlockInfo — e.g. a footer adapting to the
+   * content section directly above it.
+   *
+   * @returns {Object|null} Last body block's info or null
+   */
+  getLastBodyBlockInfo() {
+    const blocks = this.bodyBlocks
+    return blocks?.[blocks.length - 1]?.getBlockInfo() || null
+  }
+
   /**
    * Get all blocks (header, body, footer) as flat array
    * Respects page layout preferences (hide list)
@@ -394,11 +412,13 @@ export default class Page {
   /**
    * Check if page should appear in a named nav area ('header', 'footer', or any
    * foundation-declared area). The general form behind showInHeader/showInFooter.
+   * False when the page is unpublished (`hidden`), suppressed from every area
+   * (`hideIn` contains '*'), or suppressed from this specific area.
    * @param {string} area
    * @returns {boolean}
    */
   showInNav(area) {
-    return !this.hidden && !this.hideIn.includes(area)
+    return !this.hidden && !this.hideIn.includes('*') && !this.hideIn.includes(area)
   }
 
   /**

package/src/website.js

@@ -791,6 +791,39 @@ export default class Website {
     return resolvedHref
   }
 
+  /**
+   * Resolve a `page:<stable_id>` detail-page reference (from a fetch config's
+   * `detailPage`) to a locale-specific route TEMPLATE, e.g. '/blog/:slug'. The
+   * entity store interpolates each record's field into the `:param` slot to build
+   * a card's href — so a dynamic-list preview links to the collection's canonical
+   * detail page regardless of which page it sits on.
+   *
+   * O(1): a `_pageIdMap` lookup (keyed on stable_id, same map makeHref uses), NOT
+   * a page-tree scan. Returns null when the ref is unresolvable — the target page
+   * was deleted or de-dynamicized (a dangling ref); the caller degrades gracefully
+   * (leaves the record without a `route`). Rename-safe: a stable_id survives page
+   * reorganization.
+   *
+   * @param {string} pageRef - `page:<stable_id>` (bare `<stable_id>` also accepted)
+   * @returns {string|null} locale-specific route template, or null if unresolvable
+   */
+  resolveDetailPageTemplate(pageRef) {
+    if (!pageRef || typeof pageRef !== 'string') return null
+    const id = pageRef.startsWith('page:') ? pageRef.slice(5) : pageRef
+    const page = this._pageIdMap?.get(id)
+    if (!page || !page.route) {
+      if (
+        typeof console !== 'undefined' &&
+        typeof process !== 'undefined' &&
+        process?.env?.NODE_ENV !== 'production'
+      ) {
+        console.warn(`[resolveDetailPageTemplate] Detail page not found: ${pageRef}`)
+      }
+      return null
+    }
+    return this.translateRoute(page.route)
+  }
+
   /**
    * Get available languages
    * @deprecated Use getLocales() instead
@@ -1075,9 +1108,13 @@ export default class Website {
 
       // Check visibility based on navigation type
       if (!includeHidden) {
+        // `hidden` = unpublished (a fortiori not in nav). In a published build it
+        // is already pruned; this also keeps dev drafts out of the menus.
         if (page.hidden) return false
-        // navType is the requested nav area ('header'/'footer'/any foundation area);
-        // hideIn lists the areas this page is suppressed from.
+        // hideIn lists the areas this page is suppressed from; '*' suppresses it
+        // from every area (reachable-but-out-of-all-menus). navType is the
+        // requested area ('header'/'footer'/any foundation-declared area).
+        if (page.hideIn?.includes('*')) return false
         if (navType && page.hideIn?.includes(navType)) return false
       }