@uniweb/build 0.14.21 → 0.14.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.14.21",
+  "version": "0.14.23",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -59,11 +59,11 @@
     "js-yaml": "^4.1.0",
     "sharp": "^0.33.2",
     "yaml": "^2.5.0",
-    "@uniweb/content-writer": "0.2.6",
-    "@uniweb/theming": "0.1.4"
+    "@uniweb/theming": "0.1.5",
+    "@uniweb/content-writer": "0.2.6"
   },
   "optionalDependencies": {
-    "@uniweb/runtime": "0.8.20",
+    "@uniweb/runtime": "0.8.22",
     "@uniweb/content-reader": "1.1.12",
     "@uniweb/schemas": "0.2.4"
   },
@@ -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.7.14"
+    "@uniweb/core": "0.7.16"
   },
   "peerDependenciesMeta": {
     "vite": {

package/src/prerender.js

@@ -138,9 +138,20 @@ async function executeAllFetches(siteContent, siteDir, onProgress, localeInfo) {
  * @param {function} onProgress - Progress callback
  * @returns {Array} Expanded pages array with dynamic pages replaced by concrete instances
  */
-function expandDynamicPages(pages, pageFetchedData, onProgress) {
+export function expandDynamicPages(pages, pageFetchedData, onProgress) {
   const expandedPages = []
 
+  // Static pages win over the dynamic `[slug]` catch-all, matching the SPA's
+  // route resolution (Website.getPage checks exact static routes before the
+  // `:param` loop). Without this guard, a record whose param value collides
+  // with a static sibling's segment (e.g. slug:'about' + a static /blog/about)
+  // would emit a duplicate concrete route; the write loops are keyed on
+  // page.route and last-writer-wins, silently clobbering the static page's
+  // HTML. Collect the static routes up front so we can skip + warn on collision.
+  const staticRoutes = new Set(
+    pages.filter((p) => !p.isDynamic).map((p) => p.route)
+  )
+
   for (const page of pages) {
     if (!page.isDynamic) {
       // Regular page - include as-is
@@ -187,6 +198,13 @@ function expandDynamicPages(pages, pageFetchedData, onProgress) {
       // Create concrete route: /blog/:slug → /blog/my-post
       const concreteRoute = page.route.replace(`:${paramName}`, paramValue)
 
+      // Static sibling wins: skip a record whose concrete route collides with
+      // an existing static page rather than overwriting its HTML at write time.
+      if (staticRoutes.has(concreteRoute)) {
+        onProgress(`    Skipping ${concreteRoute} — a static page already claims this route (${paramName}:'${paramValue}')`)
+        continue
+      }
+
       // Deep clone the page with modifications
       const concretePage = JSON.parse(JSON.stringify(page))
       concretePage.route = concreteRoute

package/src/site/build-site-data.js

@@ -95,7 +95,9 @@ export async function buildSiteData({
 
   // 1. Collect content (pages, sections, theme, config, assets manifest).
   //    No vite needed — collectSiteContent is a plain async function.
-  let siteContent = await collectSiteContent(resolvedSiteRoot, { foundationPath })
+  //    dropUnpublished: link mode is always a published deploy — prune hidden
+  //    pages + their subtree so drafts never reach the served site.
+  let siteContent = await collectSiteContent(resolvedSiteRoot, { foundationPath, dropUnpublished: true })
 
   // 2. Compile content collections (file-based markdown/yaml/json).
   //    `writeCollectionFiles` lands them under `<siteRoot>/public/data/`;

package/src/site/content-collector.js

@@ -29,7 +29,7 @@ import { existsSync, statSync, realpathSync } from 'node:fs'
 import yaml from 'js-yaml'
 import { collectSectionAssets, mergeAssetCollections, collectConfigAssets } from './assets.js'
 import { collectSectionIcons, mergeIconCollections, buildIconManifest } from './icons.js'
-import { normalizeHideIn } from './nav-visibility.js'
+import { normalizeHideIn, dropUnpublishedPages } from './nav-visibility.js'
 import { parseFetchConfig, singularize } from './data-fetcher.js'
 import { buildTheme, extractFoundationVars } from '../theme/index.js'
 
@@ -1660,13 +1660,16 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
       }
     }
 
-    // When pages: is strict (no '...'), hide unlisted direct children from navigation
+    // When pages: is strict (no '...'), suppress unlisted direct children from
+    // every nav area — but keep them ROUTED (strict is a nav filter, not a draft
+    // toggle). This is the nav axis (`hideIn: ['*']`), not the reachability axis
+    // (`hidden`), which would drop the page from the published output entirely.
     if (strictPageNamesFM) {
       for (const page of pages) {
         const childName = getDirectChildName(page.route, parentRoute)
           || (page.sourcePath ? getDirectChildName(page.sourcePath, parentRoute) : null)
-        if (childName && !strictPageNamesFM.has(childName) && !page.hidden) {
-          page.hidden = true
+        if (childName && !strictPageNamesFM.has(childName) && !page.hideIn?.includes('*')) {
+          page.hideIn = [...(page.hideIn || []), '*']
         }
       }
     }
@@ -1797,13 +1800,15 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
     }
   }
 
-  // When pages: is strict (no '...'), hide unlisted direct children from navigation
+  // When pages: is strict (no '...'), suppress unlisted direct children from every
+  // nav area but keep them ROUTED — the nav axis (`hideIn: ['*']`), not the
+  // reachability axis (`hidden`), which would drop them from the published output.
   if (strictPageNames) {
     for (const page of pages) {
       const childName = getDirectChildName(page.route, parentRoute)
         || (page.sourcePath ? getDirectChildName(page.sourcePath, parentRoute) : null)
-      if (childName && !strictPageNames.has(childName) && !page.hidden) {
-        page.hidden = true
+      if (childName && !strictPageNames.has(childName) && !page.hideIn?.includes('*')) {
+        page.hideIn = [...(page.hideIn || []), '*']
       }
     }
   }
@@ -1823,29 +1828,49 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
  * @param {string} foundationPath - Path to foundation directory
  * @returns {Promise<{ vars: Object, layoutNames: Set<string> }>}
  */
-async function loadFoundationInfo(foundationPath) {
+export async function loadFoundationInfo(foundationPath) {
   if (!foundationPath) return { vars: {}, layoutNames: new Set() }
 
   // Try dist/meta/schema.json first (built foundation), then root schema.json
   const distSchemaPath = join(foundationPath, 'dist', 'meta', 'schema.json')
   const rootSchemaPath = join(foundationPath, 'schema.json')
 
-  const schemaPath = existsSync(distSchemaPath) ? distSchemaPath : rootSchemaPath
-
-  if (!existsSync(schemaPath)) {
-    return { vars: {}, layoutNames: new Set() }
+  const schemaPath = existsSync(distSchemaPath)
+    ? distSchemaPath
+    : existsSync(rootSchemaPath)
+      ? rootSchemaPath
+      : null
+
+  if (schemaPath) {
+    try {
+      const schemaContent = await readFile(schemaPath, 'utf8')
+      const schema = JSON.parse(schemaContent)
+      // Foundation config is in _self, support both 'vars' (new) and 'themeVars' (legacy)
+      const vars = schema._self?.vars || schema._self?.themeVars || schema.themeVars || {}
+      // Layout names from _layouts (keys are layout component names)
+      const layoutNames = new Set(schema._layouts ? Object.keys(schema._layouts) : [])
+      return { vars, layoutNames }
+    } catch (err) {
+      console.warn('[content-collector] Failed to load foundation schema:', err.message)
+      // Fall through to the source-config fallback below.
+    }
   }
 
+  // No built schema.json — the normal state for `uniweb dev` on a bundled-mode
+  // site that was never built (dev doesn't build the foundation to dist/). Read
+  // the foundation's declared vars straight from its source config
+  // (main.js / foundation.js) so theme tokens like --section-padding-y are
+  // defined; without them, components using py-[var(--section-padding-y)] render
+  // with collapsed section spacing. Layouts aren't resolved from source (they
+  // need component discovery), but they aren't needed to build the theme CSS.
   try {
-    const schemaContent = await readFile(schemaPath, 'utf8')
-    const schema = JSON.parse(schemaContent)
-    // Foundation config is in _self, support both 'vars' (new) and 'themeVars' (legacy)
-    const vars = schema._self?.vars || schema._self?.themeVars || schema.themeVars || {}
-    // Layout names from _layouts (keys are layout component names)
-    const layoutNames = new Set(schema._layouts ? Object.keys(schema._layouts) : [])
-    return { vars, layoutNames }
+    const { resolveFoundationSrcPath } = await import('../utils/foundation-source-root.js')
+    const { loadFoundationConfig } = await import('../schema.js')
+    const srcDir = resolveFoundationSrcPath(foundationPath)
+    const config = await loadFoundationConfig(srcDir)
+    return { vars: config?.vars || {}, layoutNames: new Set() }
   } catch (err) {
-    console.warn('[content-collector] Failed to load foundation schema:', err.message)
+    console.warn('[content-collector] Failed to load foundation source config:', err.message)
     return { vars: {}, layoutNames: new Set() }
   }
 }
@@ -1988,7 +2013,7 @@ async function collectLayouts(layoutDir, siteRoot, layoutNames = new Set()) {
  * @returns {Promise<Object>} Site content object with assets manifest
  */
 export async function collectSiteContent(sitePath, options = {}) {
-  const { foundationPath, configFile = 'site.yml', profile: profileName } = options
+  const { foundationPath, configFile = 'site.yml', profile: profileName, dropUnpublished = false } = options
 
   // Read site config and raw theme config
   const siteConfig = await readYamlFile(join(sitePath, configFile))
@@ -2185,7 +2210,9 @@ export async function collectSiteContent(sitePath, options = {}) {
       ...processedTheme,
       css: themeCSS
     },
-    pages,
+    // Reachability axis: on the published build paths, drop `hidden` pages and
+    // their whole subtree (cascade). Dev keeps them so drafts stay previewable.
+    pages: dropUnpublished ? dropUnpublishedPages(pages) : pages,
     // Layout area sets: { default: { header: page, footer: page, ... }, marketing: { ... } }
     layouts,
     notFound,

package/src/site/data-fetcher.js

@@ -300,6 +300,9 @@ export function parseFetchConfig(fetch) {
       where: fetch.where,
       limit: fetch.limit,
       sort: fetch.sort,
+      // Canonical detail page for a list card's href (page:<stable_id> ref;
+      // resolved to a route template + interpolated per record at runtime).
+      detailPage: fetch.detailPage,
       // Legacy post-processing (deprecated, see warning above)
       filter: fetch.filter,
     }
@@ -313,6 +316,7 @@ export function parseFetchConfig(fetch) {
     merge = false,
     transform,
     detail,
+    detailPage,
     // Query operators
     where,
     limit,
@@ -334,6 +338,8 @@ export function parseFetchConfig(fetch) {
     merge,
     transform,
     detail,
+    // Canonical detail page for a list card's href (page:<stable_id>).
+    detailPage,
     // Query operators
     where,
     limit,

package/src/site/nav-visibility.js

@@ -1,12 +1,20 @@
+// Page-visibility helpers — the two orthogonal axes a page carries:
+//   • Reachability — `hidden: bool`. `true` = excluded from the PUBLISHED output
+//     entirely (see `dropUnpublishedPages`). Still previewable in `uniweb dev`.
+//   • Nav placement — `hideIn: string[]`. Which nav areas suppress the page while
+//     it IS routed (see `normalizeHideIn`). `['*']` = suppressed from every area.
+
 /**
  * Normalize a page/folder config's navigation visibility into a `hideIn` array —
  * the list of named nav areas a page is suppressed from (layout-area names like
  * 'header', 'footer', or any foundation-declared area). The canonical form behind
  * the runtime `hideIn`, the sync `hide_in` field, and `getPageHierarchy({ for })`.
+ * The sentinel `'*'` means "suppressed from every nav area" (still routed) — it is
+ * a normal array element, interpreted by the runtime, not special-cased here.
  *
  * Reads the canonical `hideIn` (an array, or a single string for convenience) and
  * folds in the legacy `hideInHeader` / `hideInFooter` booleans for back-compat.
- * Deduped; declaration order preserved. `hidden` (all-nav exclusion) is separate.
+ * Deduped; declaration order preserved. `hidden` (reachability) is a separate axis.
  *
  * @param {object} config - a parsed page.yml / folder.yml config (or page data)
  * @returns {string[]}
@@ -27,3 +35,35 @@ export function normalizeHideIn(config = {}) {
   if (config.hideInFooter) add('footer')
   return out
 }
+
+/**
+ * Drop unpublished pages — the reachability axis. A page with `hidden: true` is
+ * excluded from the PUBLISHED output entirely, and the exclusion CASCADES to its
+ * whole subtree: drafting a container drafts the branch. Applied only on the
+ * published build paths (`uniweb build` / link-mode deploy); `uniweb dev` keeps
+ * hidden pages so in-progress work stays previewable by direct URL.
+ *
+ * Cascade is resolved via the parent-route chain (the same `parent` route strings
+ * the hierarchy is built from), so no surviving page is ever left pointing at a
+ * pruned parent — this is what avoids orphaned routes / dangling parent references
+ * that a per-node drop would create.
+ *
+ * @param {Array<object>} pages - collected page data (each with `route`, `parent`)
+ * @returns {Array<object>} pages with hidden pages and their descendants removed
+ */
+export function dropUnpublishedPages(pages) {
+  if (!Array.isArray(pages) || pages.length === 0) return pages
+  const byRoute = new Map(pages.map((p) => [p.route, p]))
+  const cache = new Map()
+  const isUnpublished = (page, seen = new Set()) => {
+    if (!page) return false
+    if (cache.has(page.route)) return cache.get(page.route)
+    if (seen.has(page.route)) return false // defensive cycle guard (trees don't cycle)
+    seen.add(page.route)
+    const parent = page.parent ? byRoute.get(page.parent) : null
+    const result = page.hidden ? true : (parent ? isUnpublished(parent, seen) : false)
+    cache.set(page.route, result)
+    return result
+  }
+  return pages.filter((p) => !isUnpublished(p))
+}

package/src/site/plugin.js

@@ -582,7 +582,9 @@ export function siteContentPlugin(options = {}) {
     async buildStart() {
       // Collect content at build start
       try {
-        siteContent = await collectSiteContent(resolvedSitePath, { foundationPath })
+        // dropUnpublished only on a production build — in dev (serve) hidden
+        // pages stay in the graph so in-progress drafts remain previewable.
+        siteContent = await collectSiteContent(resolvedSitePath, { foundationPath, dropUnpublished: isProduction })
         headHtml = await loadHeadHtml()
         console.log(`[site-content] Collected ${siteContent.pages?.length || 0} pages`)