@uniweb/build 0.1.28 → 0.1.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -51,7 +51,7 @@
   },
   "optionalDependencies": {
     "@uniweb/content-reader": "1.0.4",
-    "@uniweb/runtime": "0.2.15"
+    "@uniweb/runtime": "0.2.17"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",

package/src/site/config.js

@@ -21,8 +21,9 @@
  */
 
 import { existsSync, readFileSync } from 'node:fs'
-import { resolve, dirname } from 'node:path'
+import { resolve, dirname, join } from 'node:path'
 import yaml from 'js-yaml'
+import { generateEntryPoint } from '../generate-entry.js'
 
 /**
  * Detect foundation type from the foundation config value
@@ -177,8 +178,52 @@ export async function defineSiteConfig(options = {}) {
     foundationDevPlugin = modules[3].foundationDevPlugin
   }
 
+  // Plugin to ensure foundation entry file exists (for bundled mode with local foundation)
+  const ensureFoundationEntryPlugin = !isRuntimeMode && foundationInfo.type === 'local' ? {
+    name: 'uniweb:ensure-foundation-entry',
+    async config() {
+      const srcDir = join(foundationInfo.path, 'src')
+      const entryPath = join(srcDir, '_entry.generated.js')
+
+      // Always regenerate on dev start to ensure it's current
+      // This handles new components being added
+      if (existsSync(srcDir)) {
+        console.log('[site] Ensuring foundation entry is up to date...')
+        try {
+          await generateEntryPoint(srcDir, entryPath)
+        } catch (err) {
+          console.warn('[site] Failed to generate foundation entry:', err.message)
+        }
+      }
+    },
+
+    configureServer(server) {
+      // Watch foundation src for meta.js changes to regenerate entry
+      const srcDir = join(foundationInfo.path, 'src')
+      const entryPath = join(srcDir, '_entry.generated.js')
+
+      server.watcher.add(join(srcDir, '**', 'meta.js'))
+
+      server.watcher.on('all', async (event, path) => {
+        // Regenerate entry when meta.js files change (new/deleted components)
+        if (path.includes(srcDir) && path.endsWith('meta.js')) {
+          console.log(`[site] Foundation meta.js changed, regenerating entry...`)
+          try {
+            await generateEntryPoint(srcDir, entryPath)
+            server.ws.send({ type: 'full-reload' })
+          } catch (err) {
+            console.warn('[site] Failed to regenerate foundation entry:', err.message)
+          }
+        }
+      })
+    }
+  } : null
+
   // Build the plugins array
   const plugins = [
+    // Ensure foundation entry exists first (bundled mode only)
+    ensureFoundationEntryPlugin,
+
     // Standard plugins
     tailwind && tailwindcss(),
     react(),

package/src/site/plugin.js

@@ -37,6 +37,79 @@ import { collectSiteContent } from './content-collector.js'
 import { processAssets, rewriteSiteContentPaths } from './asset-processor.js'
 import { processAdvancedAssets } from './advanced-processors.js'
 import { processCollections, writeCollectionFiles } from './collection-processor.js'
+import { executeFetch, mergeDataIntoContent } from './data-fetcher.js'
+
+/**
+ * Execute all fetches for site content (used in dev mode)
+ * Populates section.cascadedData with fetched data
+ *
+ * @param {Object} siteContent - The collected site content
+ * @param {string} siteDir - Path to site directory
+ */
+async function executeDevFetches(siteContent, siteDir) {
+  const fetchOptions = { siteRoot: siteDir, publicDir: 'public' }
+
+  // Site-level fetch
+  let siteCascadedData = {}
+  const siteFetch = siteContent.config?.fetch
+  if (siteFetch) {
+    const result = await executeFetch(siteFetch, fetchOptions)
+    if (result.data && !result.error) {
+      siteCascadedData[siteFetch.schema] = result.data
+    }
+  }
+
+  // Process each page
+  for (const page of siteContent.pages || []) {
+    let pageCascadedData = { ...siteCascadedData }
+
+    // Page-level fetch
+    const pageFetch = page.fetch
+    if (pageFetch) {
+      const result = await executeFetch(pageFetch, fetchOptions)
+      if (result.data && !result.error) {
+        pageCascadedData[pageFetch.schema] = result.data
+      }
+    }
+
+    // Process sections
+    await processDevSectionFetches(page.sections, pageCascadedData, fetchOptions)
+  }
+}
+
+/**
+ * Process fetches for sections recursively
+ *
+ * @param {Array} sections - Sections to process
+ * @param {Object} cascadedData - Data from parent levels
+ * @param {Object} fetchOptions - Options for executeFetch
+ */
+async function processDevSectionFetches(sections, cascadedData, fetchOptions) {
+  if (!sections || !Array.isArray(sections)) return
+
+  for (const section of sections) {
+    // Execute section-level fetch
+    const sectionFetch = section.fetch
+    if (sectionFetch) {
+      const result = await executeFetch(sectionFetch, fetchOptions)
+      if (result.data && !result.error) {
+        // Merge fetched data into cascadedData for this section
+        cascadedData = {
+          ...cascadedData,
+          [sectionFetch.schema]: result.data
+        }
+      }
+    }
+
+    // Attach cascaded data to section
+    section.cascadedData = { ...cascadedData }
+
+    // Process subsections recursively
+    if (section.subsections && section.subsections.length > 0) {
+      await processDevSectionFetches(section.subsections, cascadedData, fetchOptions)
+    }
+  }
+}
 import { generateSearchIndex, isSearchEnabled, getSearchIndexFilename } from '../search/index.js'
 import { mergeTranslations } from '../i18n/merge.js'
 
@@ -274,6 +347,7 @@ export function siteContentPlugin(options = {}) {
   let server = null
   let localeTranslations = {} // Cache: { locale: translations }
   let localesDir = 'locales' // Default, updated from site config
+  let collectionsConfig = null // Cached for watcher setup
 
   /**
    * Load translations for a specific locale
@@ -332,10 +406,28 @@ export function siteContentPlugin(options = {}) {
   return {
     name: 'uniweb:site-content',
 
-    configResolved(config) {
+    async configResolved(config) {
       resolvedSitePath = resolve(config.root, sitePath)
       resolvedOutDir = resolve(config.root, config.build.outDir)
       isProduction = config.command === 'build'
+
+      // In dev mode, process collections early so JSON files exist before server starts
+      // This runs before configureServer, ensuring data is available immediately
+      if (!isProduction) {
+        try {
+          // Do an early content collection to get the collections config
+          const earlyContent = await collectSiteContent(resolvedSitePath)
+          collectionsConfig = earlyContent.config?.collections
+
+          if (collectionsConfig) {
+            console.log('[site-content] Processing content collections...')
+            const collections = await processCollections(resolvedSitePath, collectionsConfig)
+            await writeCollectionFiles(resolvedSitePath, collections)
+          }
+        } catch (err) {
+          console.warn('[site-content] Early collection processing failed:', err.message)
+        }
+      }
     },
 
     async buildStart() {
@@ -345,13 +437,20 @@ export function siteContentPlugin(options = {}) {
         console.log(`[site-content] Collected ${siteContent.pages?.length || 0} pages`)
 
         // Process content collections if defined in site.yml
-        // This generates JSON files in public/data/ BEFORE the Vite build
-        if (siteContent.config?.collections) {
+        // In dev mode, this was already done in configResolved (before server starts)
+        // In production, do it here
+        if (isProduction && siteContent.config?.collections) {
           console.log('[site-content] Processing content collections...')
           const collections = await processCollections(resolvedSitePath, siteContent.config.collections)
           await writeCollectionFiles(resolvedSitePath, collections)
         }
 
+        // Execute data fetches in dev mode
+        // In production, prerender handles this
+        if (!isProduction) {
+          await executeDevFetches(siteContent, resolvedSitePath)
+        }
+
         // Update localesDir from site config
         if (siteContent.config?.i18n?.localesDir) {
           localesDir = siteContent.config.i18n.localesDir
@@ -382,6 +481,8 @@ export function siteContentPlugin(options = {}) {
             console.log('[site-content] Content changed, rebuilding...')
             try {
               siteContent = await collectSiteContent(resolvedSitePath)
+              // Execute fetches for the updated content
+              await executeDevFetches(siteContent, resolvedSitePath)
               console.log(`[site-content] Rebuilt ${siteContent.pages?.length || 0} pages`)
 
               // Send full reload to client
@@ -399,9 +500,11 @@ export function siteContentPlugin(options = {}) {
           collectionRebuildTimeout = setTimeout(async () => {
             console.log('[site-content] Collection content changed, regenerating JSON...')
             try {
-              if (siteContent?.config?.collections) {
-                const collections = await processCollections(resolvedSitePath, siteContent.config.collections)
-                await writeCollectionFiles(resolvedSitePath, collections)
+              // Use collectionsConfig (cached from configResolved) or siteContent
+              const collections = collectionsConfig || siteContent?.config?.collections
+              if (collections) {
+                const processed = await processCollections(resolvedSitePath, collections)
+                await writeCollectionFiles(resolvedSitePath, processed)
               }
               // Send full reload to client
               server.ws.send({ type: 'full-reload' })
@@ -437,9 +540,10 @@ export function siteContentPlugin(options = {}) {
         }
 
         // Watch content/ folder for collection changes
-        if (siteContent?.config?.collections) {
+        // Use collectionsConfig cached from configResolved (siteContent may be null here)
+        if (collectionsConfig) {
           const contentPaths = new Set()
-          for (const config of Object.values(siteContent.config.collections)) {
+          for (const config of Object.values(collectionsConfig)) {
             const collectionPath = typeof config === 'string' ? config : config.path
             if (collectionPath) {
               contentPaths.add(resolve(resolvedSitePath, collectionPath))