@uniweb/build 0.6.17 → 0.6.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.6.17",
+  "version": "0.6.18",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -51,8 +51,8 @@
   },
   "optionalDependencies": {
     "@uniweb/schemas": "0.2.1",
-    "@uniweb/content-reader": "1.1.2",
-    "@uniweb/runtime": "0.5.21"
+    "@uniweb/runtime": "0.5.21",
+    "@uniweb/content-reader": "1.1.2"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",

package/src/i18n/index.js

@@ -169,21 +169,17 @@ async function resolveLocales(configLocales, localesPath) {
 /**
  * Extract manifest from site content and write to file
  * @param {string} siteRoot - Site root directory
+ * @param {Object} siteContent - Collected site content (from collectSiteContent)
  * @param {Object} options - Options
  * @returns {Object} { manifest, report }
  */
-export async function extractManifest(siteRoot, options = {}) {
+export async function extractManifest(siteRoot, siteContent, options = {}) {
   const {
     localesDir = DEFAULTS.localesDir,
-    siteContentPath = join(siteRoot, 'dist', 'site-content.json'),
     verbose = false,
     dryRun = false
   } = options
 
-  // Load site content
-  const siteContentRaw = await readFile(siteContentPath, 'utf-8')
-  const siteContent = JSON.parse(siteContentRaw)
-
   // Extract translatable content
   const manifest = extractTranslatableContent(siteContent)
 

package/src/site/content-collector.js

@@ -271,23 +271,130 @@ function compareFilenames(a, b) {
 }
 
 /**
- * Apply non-strict ordering to a list of items.
- * Listed items appear first in array order, then unlisted items in their existing order.
+ * Extract the name from a config array item.
+ * Handles both string entries ("hero") and object entries ({ features: [...] }).
+ * @param {*} item - Array item from sections: or pages: config
+ * @returns {string|null} The name, or null if not a valid entry
+ */
+function extractItemName(item) {
+  if (typeof item === 'string') return item
+  if (typeof item === 'object' && item !== null) {
+    const keys = Object.keys(item)
+    if (keys.length === 1) return keys[0]
+  }
+  return null
+}
+
+/**
+ * Parse a config array that may contain '...' rest markers.
+ *
+ * Returns structured info:
+ * - mode 'strict': no '...' — only listed items visible in navigation
+ * - mode 'inclusive': '...' present — pinned items + auto-discovered rest
+ * - mode 'all': array is just ['...'] — equivalent to omitting config
+ *
+ * @param {Array} arr - Config array (may contain '...' strings and/or objects)
+ * @returns {{ mode: 'strict'|'inclusive'|'all', before: Array, after: Array }|null}
+ */
+function parseWildcardArray(arr) {
+  if (!Array.isArray(arr) || arr.length === 0) return null
+
+  const firstRestIndex = arr.indexOf('...')
+  if (firstRestIndex === -1) {
+    return { mode: 'strict', before: [...arr], after: [] }
+  }
+
+  // Find last '...' index
+  let lastRestIndex = firstRestIndex
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (arr[i] === '...') { lastRestIndex = i; break }
+  }
+
+  const before = arr.slice(0, firstRestIndex).filter(x => x !== '...')
+  const after = arr.slice(lastRestIndex + 1).filter(x => x !== '...')
+
+  if (before.length === 0 && after.length === 0) {
+    return { mode: 'all', before: [], after: [] }
+  }
+
+  return { mode: 'inclusive', before, after }
+}
+
+/**
+ * Apply wildcard-aware ordering to a list of named items.
  *
- * Unlike strict arrays (pages: [...], sections: [...]) which hide unlisted items,
- * this preserves all items — it only affects order.
+ * - strict: listed items first in listed order, then unlisted (all items returned)
+ * - inclusive: before items, then rest (in existing order), then after items
+ * - all/null: return items unchanged
  *
  * @param {Array} items - Items with a .name property
- * @param {Array<string>} orderArray - Names in desired order
- * @returns {Array} Reordered items (all items preserved)
+ * @param {{ mode: string, before: Array, after: Array }|null} parsed - From parseWildcardArray
+ * @returns {Array} Reordered items
  */
-function applyNonStrictOrder(items, orderArray) {
-  if (!Array.isArray(orderArray) || orderArray.length === 0) return items
-  const orderMap = new Map(orderArray.map((name, i) => [name, i]))
-  const listed = items.filter(i => orderMap.has(i.name))
-    .sort((a, b) => orderMap.get(a.name) - orderMap.get(b.name))
-  const unlisted = items.filter(i => !orderMap.has(i.name))
-  return [...listed, ...unlisted]
+function applyWildcardOrder(items, parsed) {
+  if (!parsed || parsed.mode === 'all') return items
+
+  const itemMap = new Map(items.map(i => [i.name, i]))
+  const beforeNames = parsed.before.map(extractItemName).filter(Boolean)
+  const afterNames = parsed.after.map(extractItemName).filter(Boolean)
+  const allPinnedNames = new Set([...beforeNames, ...afterNames])
+
+  const beforeItems = beforeNames.filter(n => itemMap.has(n)).map(n => itemMap.get(n))
+  const afterItems = afterNames.filter(n => itemMap.has(n)).map(n => itemMap.get(n))
+  const rest = items.filter(i => !allPinnedNames.has(i.name))
+
+  if (parsed.mode === 'strict') {
+    // Listed items first, then unlisted (hiding is applied separately)
+    return [...beforeItems, ...rest]
+  }
+
+  // Inclusive: before + rest + after
+  return [...beforeItems, ...rest, ...afterItems]
+}
+
+/**
+ * Find the markdown file for a section name, handling numeric prefixes.
+ * Tries exact match first ("hero.md"), then prefix-based ("1-hero.md").
+ *
+ * @param {string} pagePath - Directory containing section files
+ * @param {string} sectionName - Logical section name (e.g., 'hero')
+ * @param {string[]} [cachedFiles] - Pre-read directory listing (optimization)
+ * @returns {{ filePath: string, stableName: string, prefix: string|null }|null}
+ */
+function findSectionFile(pagePath, sectionName, cachedFiles) {
+  const exactPath = join(pagePath, `${sectionName}.md`)
+  if (existsSync(exactPath)) {
+    return { filePath: exactPath, stableName: sectionName, prefix: null }
+  }
+
+  const files = cachedFiles || []
+  for (const file of files) {
+    if (!isMarkdownFile(file)) continue
+    const { name } = parse(file)
+    const { prefix, name: parsedName } = parseNumericPrefix(name)
+    if (parsedName === sectionName) {
+      return { filePath: join(pagePath, file), stableName: sectionName, prefix }
+    }
+  }
+
+  return null
+}
+
+/**
+ * Extract a direct child's folder name from its route, relative to parentRoute.
+ * Returns null for the index page (route === parentRoute) or non-direct-children.
+ *
+ * @param {string} route - Page route (e.g., '/about')
+ * @param {string} parentRoute - Parent route (e.g., '/')
+ * @returns {string|null}
+ */
+function getDirectChildName(route, parentRoute) {
+  if (!route || route === parentRoute) return null
+  const prefix = parentRoute === '/' ? '/' : parentRoute + '/'
+  if (!route.startsWith(prefix)) return null
+  const rest = route.slice(prefix.length)
+  if (rest.includes('/')) return null
+  return rest
 }
 
 /**
@@ -482,6 +589,9 @@ async function processExplicitSections(sectionsConfig, pagePath, siteRoot, paren
   }
   let lastModified = null
 
+  // Cache directory listing for prefix-based file resolution
+  const cachedFiles = await readdir(pagePath)
+
   let index = 1
   for (const item of sectionsConfig) {
     let sectionName
@@ -507,13 +617,14 @@ async function processExplicitSections(sectionsConfig, pagePath, siteRoot, paren
     // Build section ID
     const id = parentId ? `${parentId}.${index}` : String(index)
 
-    // Look for the markdown file
-    const filePath = join(pagePath, `${sectionName}.md`)
-    if (!existsSync(filePath)) {
+    // Look for the markdown file (exact match or prefix-based, e.g., "hero" → "1-hero.md")
+    const found = findSectionFile(pagePath, sectionName, cachedFiles)
+    if (!found) {
       console.warn(`[content-collector] Section file not found: ${sectionName}.md`)
       index++
       continue
     }
+    const filePath = found.filePath
 
     // Process the section
     // Use sectionName as stable ID for scroll targeting (e.g., "hero", "features")
@@ -579,8 +690,9 @@ async function processPage(pagePath, pageName, siteRoot, { isIndex = false, pare
 
   // Check for explicit sections configuration
   const { sections: sectionsConfig } = pageConfig
+  const sectionsParsed = Array.isArray(sectionsConfig) ? parseWildcardArray(sectionsConfig) : null
 
-  if (sectionsConfig === undefined || sectionsConfig === '*') {
+  if (sectionsConfig === undefined || sectionsConfig === '*' || sectionsParsed?.mode === 'all') {
     // Default behavior: discover all .md files, sort by numeric prefix
     const files = await readdir(pagePath)
     const mdFiles = files.filter(isMarkdownFile).sort(compareFilenames)
@@ -609,8 +721,79 @@ async function processPage(pagePath, pageName, siteRoot, { isIndex = false, pare
     // Build hierarchy from dot notation
     hierarchicalSections = buildSectionHierarchy(sections)
 
+  } else if (sectionsParsed?.mode === 'inclusive') {
+    // Inclusive: pinned sections + auto-discovered rest via '...' wildcard
+    const files = await readdir(pagePath)
+    const mdFiles = files.filter(isMarkdownFile).sort(compareFilenames)
+
+    // Build name → file info map from discovered files
+    const discoveredMap = new Map()
+    for (const file of mdFiles) {
+      const { name } = parse(file)
+      const { prefix, name: stableName } = parseNumericPrefix(name)
+      const key = stableName || name
+      if (!discoveredMap.has(key)) {
+        discoveredMap.set(key, { file, prefix, stableName: key })
+      }
+    }
+
+    // Create items with .name property for applyWildcardOrder
+    const allItems = [...discoveredMap.keys()].map(name => ({ name }))
+    const ordered = applyWildcardOrder(allItems, sectionsParsed)
+
+    // Collect subsection configs from the original array (e.g., { features: [a, b] })
+    const subsectionConfigs = new Map()
+    for (const item of [...sectionsParsed.before, ...sectionsParsed.after]) {
+      if (typeof item === 'object' && item !== null) {
+        const keys = Object.keys(item)
+        if (keys.length === 1) {
+          subsectionConfigs.set(keys[0], item[keys[0]])
+        }
+      }
+    }
+
+    // Process sections in wildcard-expanded order
+    const sections = []
+    let sectionIndex = 1
+    for (const { name } of ordered) {
+      const entry = discoveredMap.get(name)
+      if (!entry) {
+        console.warn(`[content-collector] Section '${name}' not found in ${pagePath}`)
+        continue
+      }
+
+      const id = String(sectionIndex)
+      const { section, assetCollection: sectionAssets, iconCollection: sectionIcons } =
+        await processMarkdownFile(join(pagePath, entry.file), id, siteRoot, entry.stableName)
+      sections.push(section)
+      pageAssetCollection = mergeAssetCollections(pageAssetCollection, sectionAssets)
+      pageIconCollection = mergeIconCollections(pageIconCollection, sectionIcons)
+
+      // Track last modified
+      const fileStat = await stat(join(pagePath, entry.file))
+      if (!lastModified || fileStat.mtime > lastModified) {
+        lastModified = fileStat.mtime
+      }
+
+      // Process subsections if configured (e.g., { features: [logocloud, stats] })
+      const subsections = subsectionConfigs.get(name)
+      if (Array.isArray(subsections) && subsections.length > 0) {
+        const subResult = await processExplicitSections(subsections, pagePath, siteRoot, id)
+        section.subsections = subResult.sections
+        pageAssetCollection = mergeAssetCollections(pageAssetCollection, subResult.assetCollection)
+        pageIconCollection = mergeIconCollections(pageIconCollection, subResult.iconCollection)
+        if (subResult.lastModified && (!lastModified || subResult.lastModified > lastModified)) {
+          lastModified = subResult.lastModified
+        }
+      }
+
+      sectionIndex++
+    }
+
+    hierarchicalSections = buildSectionHierarchy(sections)
+
   } else if (Array.isArray(sectionsConfig) && sectionsConfig.length > 0) {
-    // Explicit sections array
+    // Strict: explicit sections array (only listed sections processed)
     const result = await processExplicitSections(sectionsConfig, pagePath, siteRoot)
     hierarchicalSections = result.sections
     pageAssetCollection = result.assetCollection
@@ -722,9 +905,13 @@ async function processPage(pagePath, pageName, siteRoot, { isIndex = false, pare
 function determineIndexPage(orderConfig, availableFolders) {
   const { pages: pagesArray, index: indexName } = orderConfig || {}
 
-  // 1. Explicit pages array - first item is index
+  // 1. Explicit pages array - first non-'...' item is index
   if (Array.isArray(pagesArray) && pagesArray.length > 0) {
-    return pagesArray[0]
+    const parsed = parseWildcardArray(pagesArray)
+    if (parsed && parsed.before.length > 0) {
+      return extractItemName(parsed.before[0])
+    }
+    // Array starts with '...' or is ['...'] — no index from pages, fall through
   }
 
   // 2. Explicit index property
@@ -788,7 +975,6 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
     // Read folder.yml or page.yml to determine mode and get config
     const { config: dirConfig, mode: dirMode } = await readFolderConfig(entryPath, contentMode)
     const numericOrder = typeof dirConfig.order === 'number' ? dirConfig.order : undefined
-    const childOrderArray = Array.isArray(dirConfig.order) ? dirConfig.order : undefined
 
     pageFolders.push({
       name: entry,
@@ -798,8 +984,7 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
       dirMode,
       childOrderConfig: {
         pages: dirConfig.pages,
-        index: dirConfig.index,
-        order: childOrderArray
+        index: dirConfig.index
       }
     })
   }
@@ -813,8 +998,20 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
     return a.name.localeCompare(b.name)
   })
 
-  // Apply non-strict order from parent config (if present)
-  const orderedFolders = applyNonStrictOrder(pageFolders, orderConfig?.order)
+  // Apply ordering: pages: (wildcard-aware) > order: [array] (backward compat) > default
+  let orderedFolders
+  let strictPageNames = null
+
+  const pagesParsed = Array.isArray(orderConfig?.pages) ? parseWildcardArray(orderConfig.pages) : null
+
+  if (pagesParsed && pagesParsed.mode !== 'all') {
+    orderedFolders = applyWildcardOrder(pageFolders, pagesParsed)
+    if (pagesParsed.mode === 'strict') {
+      strictPageNames = new Set(pagesParsed.before.map(extractItemName).filter(Boolean))
+    }
+  } else {
+    orderedFolders = pageFolders
+  }
 
   // Check if this directory contains version folders (versioned section)
   const folderNames = orderedFolders.map(f => f.name)
@@ -879,12 +1076,28 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
       }
     }
 
-    // Apply non-strict order to md-file-pages
-    const orderedMdPages = applyNonStrictOrder(mdPageItems, orderConfig?.order)
+    // Apply ordering: pages: (wildcard-aware) > order: [array] (backward compat) > default
+    let orderedMdPages
+    let strictPageNamesFM = null
 
-    // In folder mode, only promote an index if explicitly set via index: in folder.yml
-    // The container page itself owns the parent route — don't auto-promote children
-    const indexName = orderConfig?.index || null
+    const pagesParsedFM = Array.isArray(orderConfig?.pages) ? parseWildcardArray(orderConfig.pages) : null
+
+    if (pagesParsedFM && pagesParsedFM.mode !== 'all') {
+      orderedMdPages = applyWildcardOrder(mdPageItems, pagesParsedFM)
+      if (pagesParsedFM.mode === 'strict') {
+        strictPageNamesFM = new Set(pagesParsedFM.before.map(extractItemName).filter(Boolean))
+      }
+    } else {
+      orderedMdPages = mdPageItems
+    }
+
+    // In folder mode, determine index: pages: first item, or explicit index:
+    let indexName = null
+    if (pagesParsedFM && pagesParsedFM.before.length > 0) {
+      indexName = extractItemName(pagesParsedFM.before[0])
+    } else {
+      indexName = orderConfig?.index || null
+    }
 
     // Add md-file-pages
     for (const { name, result } of orderedMdPages) {
@@ -984,6 +1197,17 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
       }
     }
 
+    // When pages: is strict (no '...'), hide unlisted direct children from navigation
+    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
+        }
+      }
+    }
+
     return { pages, assetCollection, iconCollection, notFound, versionedScopes }
   }
 
@@ -1092,6 +1316,17 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
     }
   }
 
+  // When pages: is strict (no '...'), hide unlisted direct children from navigation
+  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
+      }
+    }
+  }
+
   return { pages, assetCollection, iconCollection, notFound, versionedScopes }
 }
 
@@ -1232,8 +1467,7 @@ export async function collectSiteContent(sitePath, options = {}) {
   // Extract page ordering config from site.yml
   const siteOrderConfig = {
     pages: siteConfig.pages,
-    index: siteConfig.index,
-    order: Array.isArray(siteConfig.order) ? siteConfig.order : undefined
+    index: siteConfig.index
   }
 
   // Determine root content mode from folder.yml/page.yml presence in pages directory
@@ -1291,8 +1525,11 @@ export async function collectSiteContent(sitePath, options = {}) {
     page.parent = parentPage ? parentPage.route : null
   }
 
-  // Sort pages by order
-  pages.sort((a, b) => (a.order ?? 999) - (b.order ?? 999))
+  // Page order is determined by per-level sorting during collection:
+  // 1. Numeric 'order' property in page.yml (lower first, within each level)
+  // 2. pages: array in parent config (wildcard-aware, overrides numeric order)
+  // 3. order: [array] in parent config (non-strict, backward compat)
+  // No global re-sort — collection order is authoritative.
 
   // Log asset summary
   const assetCount = Object.keys(assetCollection.assets).length
@@ -1335,4 +1572,12 @@ export async function collectSiteContent(sitePath, options = {}) {
   }
 }
 
+// Exported for testing
+export {
+  extractItemName,
+  parseWildcardArray,
+  applyWildcardOrder,
+  getDirectChildName
+}
+
 export default collectSiteContent