@uniweb/core 0.7.10 → 0.7.12

package/README.md

@@ -129,8 +129,8 @@ page.website                  // Back-reference to parent Website
 
 // Navigation visibility
 page.hidden                   // Hidden from all navigation
-page.hideInHeader             // Hidden from header nav only
-page.hideInFooter             // Hidden from footer nav only
+page.hideIn                   // Nav areas this page is hidden from (e.g. ['header'])
+page.showInNav(area)          // Should appear in a given named nav area?
 page.isHidden()               // Check if hidden from navigation
 page.showInHeader()           // Should appear in header nav?
 page.showInFooter()           // Should appear in footer nav?
@@ -165,8 +165,7 @@ order: 2
 
 # Navigation visibility
 hidden: true                  # Hide from all navigation
-hideInHeader: true            # Hide from header nav only
-hideInFooter: true            # Hide from footer nav only
+hideIn: [header]              # Hide from named nav areas only (header, footer, sidebar, …)
 
 # Layout overrides (default: all true)
 layout:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/core",
-  "version": "0.7.10",
+  "version": "0.7.12",
   "description": "Core classes for the Uniweb platform - Uniweb, Website, Page, Block",
   "type": "module",
   "exports": {
@@ -27,13 +27,13 @@
     "node": ">=20.19"
   },
   "devDependencies": {
-    "jest": "^29.7.0"
+    "vitest": "^4.1.7"
   },
   "dependencies": {
     "@uniweb/semantic-parser": "1.1.17",
     "@uniweb/theming": "0.1.3"
   },
   "scripts": {
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
+    "test": "vitest run"
   }
 }

package/src/entity-store.js

@@ -14,7 +14,6 @@
  * and in-flight dedup.
  */
 
-import singularize from './singularize.js'
 import { substitutePlaceholders } from './substitute-placeholders.js'
 
 /**
@@ -220,7 +219,7 @@ export default class EntityStore {
     if (detail && typeof detail === 'object') {
       const out = {
         ...(isLocalPath ? { path: baseUrl } : { url: baseUrl }),
-        schema: singularize(collectionConfig.schema) || collectionConfig.schema,
+        schema: collectionConfig.schema,
         transform: collectionConfig.transform,
       }
       if (collectionConfig.method) out.method = collectionConfig.method
@@ -253,32 +252,11 @@ export default class EntityStore {
 
     return {
       ...(isLocalPath ? { path: detailUrl } : { url: detailUrl }),
-      schema: singularize(collectionConfig.schema) || collectionConfig.schema,
+      schema: collectionConfig.schema,
       transform: collectionConfig.transform,
     }
   }
 
-  /**
-   * For dynamic routes: extract the matching item from a collection and
-   * expose it under the singular schema key (articles → article).
-   */
-  _resolveSingularItem(data, dynamicContext) {
-    if (!dynamicContext) return data
-    const { paramName, paramValue, schema: pluralSchema } = dynamicContext
-    if (!pluralSchema || !paramName || paramValue === undefined) return data
-    const items = data[pluralSchema]
-    if (!Array.isArray(items)) return data
-
-    const singularSchema = singularize(pluralSchema)
-    const currentItem = items.find(
-      (item) => String(item[paramName]) === String(paramValue)
-    )
-    if (currentItem && singularSchema) {
-      return { ...data, [singularSchema]: currentItem }
-    }
-    return data
-  }
-
   /**
    * Build the `ctx` handed to the dispatcher for a given block.
    * @private
@@ -326,9 +304,12 @@ export default class EntityStore {
     const data = {}
     let allCached = true
 
+    const routeSchema = dynamicContext?.schema
+
     for (const [schema, cfg] of configs) {
-      if (dynamicContext && cfg.detail && !inheritDetail) {
-        // detail: false — return collection minus the active item.
+      const isRouteCollection = dynamicContext && schema === routeSchema
+      if (isRouteCollection && !inheritDetail) {
+        // refine detail:false — the collection minus the active item (related items).
         const cached = dispatcher?.peek(cfg, ctx)
         if (cached) {
           const { paramName, paramValue } = dynamicContext
@@ -341,29 +322,31 @@ export default class EntityStore {
         } else {
           allCached = false
         }
-      } else if (dynamicContext && cfg.detail) {
-        // Collection-first detail: the collection is the content gate.
-        const cachedCollection = dispatcher?.peek(cfg, ctx)
-        if (cachedCollection) {
-          const collectionItems = cachedCollection.data
+      } else if (isRouteCollection) {
+        // Detail page: deliver the focused record as a length-1 array under the
+        // collection key. Deferred/API collections fetch the full per-record;
+        // others use the matched item from the collection. Not found → [].
+        const cached = dispatcher?.peek(cfg, ctx)
+        if (cached) {
           const { paramName, paramValue } = dynamicContext
-          const singularKey = singularize(schema) || schema
-          const match = Array.isArray(collectionItems)
-            ? collectionItems.find((item) => String(item[paramName]) === String(paramValue))
+          const items = cached.data
+          const match = Array.isArray(items)
+            ? items.find((item) => String(item[paramName]) === String(paramValue))
             : null
-
           if (!match) {
-            data[singularKey] = null
-          } else {
+            data[schema] = []
+          } else if (cfg.detail) {
             const detailCfg = this._buildDetailConfig(cfg, dynamicContext)
             const detailCached = detailCfg ? dispatcher?.peek(detailCfg, ctx) : null
             if (detailCfg && detailCached) {
-              data[singularKey] = detailCached.data
+              data[schema] = [detailCached.data]
             } else if (detailCfg) {
               allCached = false
             } else {
-              data[singularKey] = match
+              data[schema] = [match]
             }
+          } else {
+            data[schema] = [match]
           }
         } else {
           allCached = false
@@ -380,8 +363,7 @@ export default class EntityStore {
     }
 
     if (allCached) {
-      const resolved = this._resolveSingularItem(data, dynamicContext)
-      return { status: 'ready', data: resolved }
+      return { status: 'ready', data }
     }
     return { status: 'pending', data: null }
   }
@@ -418,9 +400,12 @@ export default class EntityStore {
     const data = {}
     const parallelFetches = []
 
+    const routeSchema = dynamicContext?.schema
+
     for (const [schema, cfg] of configs) {
-      if (dynamicContext && cfg.detail && !inheritDetail) {
-        // detail: false — collection-only, minus the active item.
+      const isRouteCollection = dynamicContext && schema === routeSchema
+      if (isRouteCollection && !inheritDetail) {
+        // refine detail:false — the collection minus the active item.
         let collectionItems = peekArray(dispatcher, cfg, ctx)
         if (collectionItems === null) {
           const result = await dispatcher.dispatch(cfg, ctx)
@@ -432,10 +417,9 @@ export default class EntityStore {
           : (collectionItems ?? [])
         if (order) filtered = this._sortItems(filtered, order)
         data[schema] = limit && Array.isArray(filtered) ? filtered.slice(0, limit) : filtered
-      } else if (dynamicContext && cfg.detail) {
-        // Collection-first detail resolution.
+      } else if (isRouteCollection) {
+        // Detail page: focused record as a length-1 array under the collection key.
         const { paramName, paramValue } = dynamicContext
-        const singularKey = singularize(schema) || schema
 
         let collectionItems = peekArray(dispatcher, cfg, ctx)
         if (collectionItems === null) {
@@ -448,21 +432,26 @@ export default class EntityStore {
         ) ?? null
 
         if (!match) {
-          data[singularKey] = null
+          data[schema] = []
           continue
         }
 
-        const detailCfg = this._buildDetailConfig(cfg, dynamicContext)
-        if (detailCfg) {
-          parallelFetches.push(
-            dispatcher.dispatch(detailCfg, ctx).then((result) => {
-              data[singularKey] = (result?.data !== undefined && result?.data !== null)
-                ? result.data
-                : match
-            })
-          )
+        if (cfg.detail) {
+          const detailCfg = this._buildDetailConfig(cfg, dynamicContext)
+          if (detailCfg) {
+            parallelFetches.push(
+              dispatcher.dispatch(detailCfg, ctx).then((result) => {
+                const record = (result?.data !== undefined && result?.data !== null)
+                  ? result.data
+                  : match
+                data[schema] = [record]
+              })
+            )
+          } else {
+            data[schema] = [match]
+          }
         } else {
-          data[singularKey] = match
+          data[schema] = [match]
         }
       } else {
         parallelFetches.push(
@@ -476,8 +465,7 @@ export default class EntityStore {
     }
 
     if (parallelFetches.length > 0) await Promise.all(parallelFetches)
-    const resolved = this._resolveSingularItem(data, dynamicContext)
-    return { data: resolved }
+    return { data }
   }
 }
 

package/src/fetcher-dispatcher.js

@@ -44,7 +44,13 @@ function collectTransports(decl, { source, dev }) {
 
   let raw
   try {
-    raw = decl.transports
+    // A built foundation carries its declarations under `default.capabilities`
+    // — framework/build/src/generate-entry.js spreads the source `main.js`
+    // default (props, transports, …) into `capabilities`, and `decl` here is
+    // that built `default` (= { meta, capabilities, layoutMeta }). Transports
+    // therefore live at `default.capabilities.transports`: a single direct
+    // read, no fallback chain (the runtime only ever sees the built shape).
+    raw = decl.capabilities?.transports
   } catch (err) {
     if (dev) console.warn(`[FetcherDispatcher] ${source} transports getter threw:`, err)
     return out

package/src/index.js

@@ -19,7 +19,6 @@ export { default as FetcherDispatcher } from './fetcher-dispatcher.js'
 export { default as ObservableState } from './observable-state.js'
 
 // Utilities
-export { default as singularize } from './singularize.js'
 export { substitutePlaceholders } from './substitute-placeholders.js'
 export { evaluate as evaluateWhere, match as matchWhere } from './where.js'
 export { isRichSchema } from './schemas.js'

package/src/page.js

@@ -8,6 +8,26 @@
 import Block from './block.js'
 import ObservableState from './observable-state.js'
 
+// Normalize a page's nav-visibility into a deduped hideIn array (the layout-area
+// names the page is suppressed from). Reads the canonical hideIn (array, or a single
+// string) and folds in the legacy hideInHeader/hideInFooter booleans for back-compat.
+function normalizeHideIn(pageData) {
+  const out = []
+  const seen = new Set()
+  const add = (a) => {
+    if (typeof a === 'string' && a && !seen.has(a)) {
+      seen.add(a)
+      out.push(a)
+    }
+  }
+  const raw = pageData.hideIn
+  if (Array.isArray(raw)) raw.forEach(add)
+  else add(raw)
+  if (pageData.hideInHeader) add('header')
+  if (pageData.hideInFooter) add('footer')
+  return out
+}
+
 export default class Page {
   constructor(pageData, id, website) {
     this.id = id
@@ -27,10 +47,14 @@ export default class Page {
     // Rewrite target (if set, this route is served by an external site)
     this.rewrite = pageData.rewrite || null
 
-    // Navigation visibility options
+    // 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.
     this.hidden = pageData.hidden || false
-    this.hideInHeader = pageData.hideInHeader || false
-    this.hideInFooter = pageData.hideInFooter || false
+    this.hideIn = normalizeHideIn(pageData)
+    this.hideInHeader = this.hideIn.includes('header')
+    this.hideInFooter = this.hideIn.includes('footer')
 
     // Layout options (named layout + per-page overrides)
     this.layout = {
@@ -368,12 +392,22 @@ export default class Page {
     return this.hidden
   }
 
+  /**
+   * Check if page should appear in a named nav area ('header', 'footer', or any
+   * foundation-declared area). The general form behind showInHeader/showInFooter.
+   * @param {string} area
+   * @returns {boolean}
+   */
+  showInNav(area) {
+    return !this.hidden && !this.hideIn.includes(area)
+  }
+
   /**
    * Check if page should appear in header navigation
    * @returns {boolean}
    */
   showInHeader() {
-    return !this.hidden && !this.hideInHeader
+    return this.showInNav('header')
   }
 
   /**
@@ -381,7 +415,7 @@ export default class Page {
    * @returns {boolean}
    */
   showInFooter() {
-    return !this.hidden && !this.hideInFooter
+    return this.showInNav('footer')
   }
 
   /**
@@ -426,11 +460,34 @@ export default class Page {
     this._loadingContent = (async () => {
       try {
         const base = this.website.basePath || ''
-        // Locale-aware URL: non-default locale pages live under /{locale}/_pages/
-        const localePrefix = this.website.activeLocale !== this.website.defaultLocale
-          ? `/${this.website.activeLocale}` : ''
-        const routePath = this.route === '/' ? '/index' : this.route
-        const res = await fetch(`${base}${localePrefix}/_pages${routePath}.json`)
+        const lang = this.website.activeLocale
+        const defaultLang = this.website.defaultLocale
+
+        // Phase 5 of the CDN migration: prefer the content-addressed URL from
+        // __DATA__.config.pageHashes (the publish handler emits it). Falls
+        // back to the legacy /{lang}/_pages/{route}.json shape when the map
+        // isn't present (older sites that haven't republished yet).
+        const hashes = this.website.config?.pageHashes
+        const hashedUrl = hashes?.[lang]?.[this.route]
+
+        let url
+        if (hashedUrl) {
+          url = `${base}${hashedUrl}`
+        } else {
+          const localePrefix = lang !== defaultLang ? `/${lang}` : ''
+          const routePath = this.route === '/' ? '/index' : this.route
+          url = `${base}${localePrefix}/_pages${routePath}.json`
+        }
+
+        const res = await fetch(url)
+        if (res.status === 404 && _shouldReloadOnHashed404(hashedUrl)) {
+          // Stale tab: this tab's __DATA__ map references a publish that
+          // no longer exists in R2. One reload usually picks up the fresh
+          // HTML (and a fresh map). Capped at 2 attempts to defend against
+          // a malformed publish where new HTML and new R2 also disagree.
+          window.location.reload()
+          return
+        }
         if (!res.ok) {
           console.warn(`[Page] Failed to load content for ${this.route}: ${res.status}`)
           this._bodySections = []  // Mark as loaded (empty) to prevent retries
@@ -439,6 +496,11 @@ export default class Page {
         const data = await res.json()
         this._bodySections = data.sections || []
         this._bodyBlocks = null  // Reset lazy cache so getter rebuilds
+        // Reset the reload counter on a successful fetch so future stale
+        // tabs (across many publishes in one session) get fresh attempts.
+        if (typeof sessionStorage !== 'undefined') {
+          sessionStorage.removeItem('uniwebReloadCount')
+        }
       } finally {
         this._loadingContent = null
       }
@@ -609,3 +671,33 @@ export default class Page {
     return this.website.getVersionUrl(targetVersion, this.route)
   }
 }
+
+/**
+ * Helper for the stale-tab 404→reload guard in Page.loadContent.
+ *
+ * Phase 5 of the CDN migration writes content-addressed `_pages/...-{hash}.json`
+ * files. Each publish wipes the prior hashes from R2 and writes fresh ones.
+ * A browser tab loaded against a previous publish carries a stale __DATA__
+ * map; on SPA navigation it'll request a hash that no longer exists.
+ * Reloading the tab pulls fresh HTML (and a fresh map). The session-scoped
+ * counter caps reloads at 2 so a malformed publish (where new HTML and new
+ * R2 disagree) doesn't trigger an infinite loop — after 2 failed reloads
+ * we render the synthetic 404 path instead.
+ *
+ * Only fires when the request was a hashed URL: legacy non-hashed 404s
+ * keep the prior "mark empty, log warning" behavior (they're not symptomatic
+ * of a stale-tab race; just a missing route).
+ */
+function _shouldReloadOnHashed404(hashedUrl) {
+  if (!hashedUrl) return false
+  if (typeof sessionStorage === 'undefined') return false
+  if (typeof window === 'undefined' || !window.location) return false
+  try {
+    const count = parseInt(sessionStorage.getItem('uniwebReloadCount') || '0', 10) || 0
+    if (count >= 2) return false
+    sessionStorage.setItem('uniwebReloadCount', String(count + 1))
+    return true
+  } catch {
+    return false
+  }
+}

package/src/website.js

@@ -9,7 +9,6 @@ import DataStore from './datastore.js'
 import EntityStore from './entity-store.js'
 import FetcherDispatcher from './fetcher-dispatcher.js'
 import ObservableState from './observable-state.js'
-import singularize from './singularize.js'
 
 /**
  * Website — orchestration root for a single site instance.
@@ -536,7 +535,6 @@ export default class Website {
     const paramName = Object.keys(params)[0]
     const paramValue = Object.values(params)[0]
     const pluralSchema = originalData.parentSchema // e.g., 'articles'
-    const singularSchema = this._singularize(pluralSchema) // e.g., 'article'
 
     // Store dynamic context for components to access
     pageData.dynamicContext = {
@@ -545,7 +543,6 @@ export default class Website {
       paramName,
       paramValue,
       schema: pluralSchema,
-      singularSchema,
     }
 
     // Set dynamic context on sections so Block instances receive it
@@ -607,14 +604,6 @@ export default class Website {
     return { page: dynamicPage, collectionLoaded: pageData._collectionLoaded ?? true }
   }
 
-  /**
-   * Singularize a plural schema name
-   * @private
-   */
-  _singularize(name) {
-    return singularize(name)
-  }
-
   /**
    * Set active page by route
    * @param {string} route
@@ -1078,8 +1067,9 @@ export default class Website {
       // Check visibility based on navigation type
       if (!includeHidden) {
         if (page.hidden) return false
-        if (navType === 'header' && page.hideInHeader) return false
-        if (navType === 'footer' && page.hideInFooter) return false
+        // navType is the requested nav area ('header'/'footer'/any foundation area);
+        // hideIn lists the areas this page is suppressed from.
+        if (navType && page.hideIn?.includes(navType)) return false
       }
 
       // Skip content-less containers that have no visible or navigable children.

package/src/where.js

@@ -7,8 +7,6 @@
  * (which translate to their native query language) or to this evaluator
  * (which walks the object against a record).
  *
- * Architecture: see kb/framework/architecture/data-fetching.md.
- *
  * Shape:
  *
  *   {

package/src/singularize.js

@@ -1,40 +0,0 @@
-/**
- * Singularize a plural schema name
- *
- * Converts common English plural forms to singular.
- * Used by EntityStore to derive singular keys (e.g., 'articles' → 'article').
- *
- * @param {string} name - Plural name
- * @returns {string} Singular form
- */
-export default function singularize(name) {
-  if (!name) return name
-  // Common irregular plurals
-  const irregulars = {
-    people: 'person',
-    children: 'child',
-    men: 'men',
-    women: 'woman',
-    series: 'series',
-  }
-  if (irregulars[name]) return irregulars[name]
-  // -ies → -y (categories → category)
-  if (name.endsWith('ies')) return name.slice(0, -3) + 'y'
-  // -es endings that should only remove 's' (not 'es')
-  // e.g., articles → article, courses → course
-  if (name.endsWith('es')) {
-    // Check if the base word ends in a consonant that requires 'es' plural
-    // (boxes, dishes, classes, heroes) vs just 's' plural (articles, courses)
-    const base = name.slice(0, -2)
-    const lastChar = base.slice(-1)
-    // If base ends in s, x, z, ch, sh - these need 'es' for plural, so remove 'es'
-    if (['s', 'x', 'z'].includes(lastChar) || base.endsWith('ch') || base.endsWith('sh')) {
-      return base
-    }
-    // Otherwise just remove 's' (articles → article)
-    return name.slice(0, -1)
-  }
-  // Regular -s plurals
-  if (name.endsWith('s')) return name.slice(0, -1)
-  return name
-}