@uniweb/build 0.4.10 → 0.6.0

package/src/i18n/index.js

@@ -20,6 +20,7 @@ import {
   extractCollectionContent,
   buildLocalizedCollections,
   getCollectionLocales,
+  translateCollectionData,
   COLLECTIONS_DIR
 } from './collections.js'
 import { generateSearchIndex, isSearchEnabled } from '../search/index.js'
@@ -69,6 +70,7 @@ export {
   extractCollectionContent,
   buildLocalizedCollections,
   getCollectionLocales,
+  translateCollectionData,
   COLLECTIONS_DIR,
 
   // Locale resolution

package/src/prerender.js

@@ -26,19 +26,19 @@ let preparePropsSSR, getComponentMetaSSR
  * @param {Object} siteContent - The site content from site-content.json
  * @param {string} siteDir - Path to the site directory
  * @param {function} onProgress - Progress callback
- * @returns {Object} { siteCascadedData, pageFetchedData } - Fetched data for dynamic route expansion
+ * @returns {Object} { pageFetchedData, fetchedData } - Fetched data for dynamic route expansion and DataStore pre-population
  */
 async function executeAllFetches(siteContent, siteDir, onProgress) {
   const fetchOptions = { siteRoot: siteDir, publicDir: 'public' }
+  const fetchedData = [] // Collected for DataStore pre-population
 
-  // 1. Site-level fetch (cascades to all pages)
-  let siteCascadedData = {}
+  // 1. Site-level fetch
   const siteFetch = siteContent.config?.fetch
   if (siteFetch && siteFetch.prerender !== false) {
     onProgress(`  Fetching site data: ${siteFetch.path || siteFetch.url}`)
     const result = await executeFetch(siteFetch, fetchOptions)
     if (result.data && !result.error) {
-      siteCascadedData[siteFetch.schema] = result.data
+      fetchedData.push({ config: siteFetch, data: result.data })
     }
   }
 
@@ -46,14 +46,13 @@ async function executeAllFetches(siteContent, siteDir, onProgress) {
   const pageFetchedData = new Map()
 
   for (const page of siteContent.pages || []) {
-    // Page-level fetch (cascades to sections in this page)
-    let pageCascadedData = { ...siteCascadedData }
+    // Page-level fetch
     const pageFetch = page.fetch
     if (pageFetch && pageFetch.prerender !== false) {
       onProgress(`  Fetching page data for ${page.route}: ${pageFetch.path || pageFetch.url}`)
       const result = await executeFetch(pageFetch, fetchOptions)
       if (result.data && !result.error) {
-        pageCascadedData[pageFetch.schema] = result.data
+        fetchedData.push({ config: pageFetch, data: result.data })
         // Store for dynamic route expansion
         pageFetchedData.set(page.route, {
           schema: pageFetch.schema,
@@ -62,11 +61,11 @@ async function executeAllFetches(siteContent, siteDir, onProgress) {
       }
     }
 
-    // Process sections recursively (handles subsections too)
-    await processSectionFetches(page.sections, pageCascadedData, fetchOptions, onProgress)
+    // Process section-level fetches (own fetch → parsedContent.data, not cascaded)
+    await processSectionFetches(page.sections, fetchOptions, onProgress)
   }
 
-  return { siteCascadedData, pageFetchedData }
+  return { pageFetchedData, fetchedData }
 }
 
 /**
@@ -142,12 +141,6 @@ function expandDynamicPages(pages, pageFetchedData, onProgress) {
         allItems: items,      // All items from parent
       }
 
-      // Also inject into sections' cascadedData for components with inheritData
-      injectDynamicData(concretePage.sections, {
-        [singularSchema]: item,  // Current item as singular
-        [schema]: items,          // All items as plural
-      })
-
       // Use item data for page metadata if available
       if (item.title) concretePage.title = item.title
       if (item.description || item.excerpt) concretePage.description = item.description || item.excerpt
@@ -159,38 +152,15 @@ function expandDynamicPages(pages, pageFetchedData, onProgress) {
   return expandedPages
 }
 
-/**
- * Inject dynamic route data into section cascadedData
- * This ensures components with inheritData receive the current item
- *
- * @param {Array} sections - Sections to update
- * @param {Object} data - Data to inject { article: {...}, articles: [...] }
- */
-function injectDynamicData(sections, data) {
-  if (!sections || !Array.isArray(sections)) return
-
-  for (const section of sections) {
-    section.cascadedData = {
-      ...(section.cascadedData || {}),
-      ...data,
-    }
-
-    // Recurse into subsections
-    if (section.subsections && section.subsections.length > 0) {
-      injectDynamicData(section.subsections, data)
-    }
-  }
-}
-
 /**
  * Process fetch configs for sections (and subsections recursively)
+ * Section-level fetches merge data into parsedContent.data (not cascaded).
  *
  * @param {Array} sections - Array of section objects
- * @param {Object} cascadedData - Data cascaded from site/page level
  * @param {Object} fetchOptions - Options for executeFetch
  * @param {function} onProgress - Progress callback
  */
-async function processSectionFetches(sections, cascadedData, fetchOptions, onProgress) {
+async function processSectionFetches(sections, fetchOptions, onProgress) {
   if (!sections || !Array.isArray(sections)) return
 
   for (const section of sections) {
@@ -210,12 +180,9 @@ async function processSectionFetches(sections, cascadedData, fetchOptions, onPro
       }
     }
 
-    // Attach cascaded data for components with inheritData
-    section.cascadedData = cascadedData
-
     // Process subsections recursively
     if (section.subsections && section.subsections.length > 0) {
-      await processSectionFetches(section.subsections, cascadedData, fetchOptions, onProgress)
+      await processSectionFetches(section.subsections, fetchOptions, onProgress)
     }
   }
 }
@@ -329,6 +296,13 @@ function getWrapperProps(block) {
     style.position = 'relative'
   }
 
+  // Apply context overrides as inline CSS custom properties (mirrors BlockRenderer.jsx)
+  if (block.contextOverrides) {
+    for (const [key, value] of Object.entries(block.contextOverrides)) {
+      style[`--${key}`] = value
+    }
+  }
+
   const sectionId = block.stableId || block.id
   return { id: `section-${sectionId}`, style, className, background }
 }
@@ -372,18 +346,16 @@ function renderBackground(background) {
 
   if (background.mode === 'gradient' && background.gradient) {
     const g = background.gradient
-    const angle = g.angle || 0
-    const start = g.start || 'transparent'
-    const end = g.end || 'transparent'
-    const startPos = g.startPosition || 0
-    const endPos = g.endPosition || 100
+    // Raw CSS gradient string (e.g., "linear-gradient(to bottom, #000, #333)")
+    const bgValue = typeof g === 'string' ? g
+      : `linear-gradient(${g.angle || 0}deg, ${g.start || 'transparent'} ${g.startPosition || 0}%, ${g.end || 'transparent'} ${g.endPosition || 100}%)`
     children.push(
       React.createElement('div', {
         key: 'bg-gradient',
         className: 'background-gradient',
         style: {
           position: 'absolute', inset: '0',
-          background: `linear-gradient(${angle}deg, ${start} ${startPos}%, ${end} ${endPos}%)`
+          background: bgValue
         },
         'aria-hidden': 'true'
       })
@@ -449,7 +421,8 @@ function renderBackground(background) {
 
 /**
  * Render a single block for SSR
- * Mirrors BlockRenderer.jsx but without hooks (no runtime data fetching in SSR)
+ * Mirrors BlockRenderer.jsx but without hooks (no runtime data fetching in SSR).
+ * block.dataLoading is always false at prerender time — runtime fetches only happen client-side.
  */
 function renderBlock(block) {
   const Component = block.initComponent()
@@ -462,35 +435,37 @@ function renderBlock(block) {
   }
 
   // Build content and params with runtime guarantees
-  let content, params
-
-  if (block.parsedContent?._isPoc) {
-    content = block.parsedContent._pocContent
-    params = block.properties
-  } else {
-    const meta = getComponentMetaSSR(block.type)
-    const prepared = preparePropsSSR(block, meta)
-    params = prepared.params
-    content = {
-      ...prepared.content,
-      ...block.properties,
-      _prosemirror: block.parsedContent
-    }
+  const meta = getComponentMetaSSR(block.type)
+  const prepared = preparePropsSSR(block, meta)
+  let params = prepared.params
+  let content = {
+    ...prepared.content,
+    ...block.properties,
   }
 
   // Background handling (mirrors BlockRenderer.jsx)
   const { background, ...wrapperProps } = getWrapperProps(block)
-  const meta = getComponentMetaSSR(block.type)
-  const hasBackground = background?.mode && meta?.background !== 'self'
 
-  if (hasBackground) {
-    params = { ...params, _hasBackground: true }
+  // Merge Component.className (static classes declared on the component function)
+  // Order: context-{theme} + block.state.className + Component.className
+  const componentClassName = Component.className
+  if (componentClassName) {
+    wrapperProps.className = wrapperProps.className
+      ? `${wrapperProps.className} ${componentClassName}`
+      : componentClassName
   }
 
+  const hasBackground = background?.mode && meta?.background !== 'self'
+
+  block.hasBackground = hasBackground
+
+  // Use Component.as as the wrapper tag (default: 'section')
+  const wrapperTag = Component.as || 'section'
+
   const componentProps = { content, params, block }
 
   if (hasBackground) {
-    return React.createElement('section', wrapperProps,
+    return React.createElement(wrapperTag, wrapperProps,
       renderBackground(background),
       React.createElement('div', { className: 'relative z-10' },
         React.createElement(Component, componentProps)
@@ -498,7 +473,7 @@ function renderBlock(block) {
     )
   }
 
-  return React.createElement('section', wrapperProps,
+  return React.createElement(wrapperTag, wrapperProps,
     React.createElement(Component, componentProps)
   )
 }
@@ -678,7 +653,10 @@ export async function prerenderSite(siteDir, options = {}) {
 
     // Execute data fetches (site, page, section levels)
     onProgress('Executing data fetches...')
-    const { siteCascadedData, pageFetchedData } = await executeAllFetches(siteContent, siteDir, onProgress)
+    const { pageFetchedData, fetchedData } = await executeAllFetches(siteContent, siteDir, onProgress)
+
+    // Store fetchedData on siteContent for runtime DataStore pre-population
+    siteContent.fetchedData = fetchedData
 
     // Expand dynamic pages (e.g., /blog/:slug → /blog/post-1, /blog/post-2)
     if (siteContent.pages?.some(p => p.isDynamic)) {
@@ -693,6 +671,14 @@ export async function prerenderSite(siteDir, options = {}) {
     // Initialize the Uniweb runtime for this locale
     onProgress('Initializing runtime...')
     const uniweb = createUniweb(siteContent)
+
+    // Pre-populate DataStore so EntityStore can resolve data during prerender
+    if (fetchedData.length > 0 && uniweb.activeWebsite?.dataStore) {
+      for (const entry of fetchedData) {
+        uniweb.activeWebsite.dataStore.set(entry.config, entry.data)
+      }
+    }
+
     uniweb.setFoundation(foundation)
 
     // Set base path from site config so components can access it during SSR

package/src/runtime-schema.js

@@ -197,15 +197,36 @@ export function extractRuntimeSchema(fullMeta) {
   }
 
   // Data binding (CMS entities)
+  // Supports both old format (data: 'person:6') and new consolidated format
+  // (data: { entity: 'person:6', schemas: {...}, inherit: [...] })
   if (fullMeta.data) {
-    const parsed = parseDataString(fullMeta.data)
-    if (parsed) {
-      runtime.data = parsed
+    if (typeof fullMeta.data === 'string') {
+      // Old format: data: 'person:6'
+      const parsed = parseDataString(fullMeta.data)
+      if (parsed) {
+        runtime.data = parsed
+      }
+    } else if (typeof fullMeta.data === 'object') {
+      // New format: data: { entity, schemas, inherit }
+      if (fullMeta.data.entity) {
+        const parsed = parseDataString(fullMeta.data.entity)
+        if (parsed) {
+          runtime.data = parsed
+        }
+      }
+      if (fullMeta.data.schemas) {
+        const schemas = extractSchemas(fullMeta.data.schemas)
+        if (schemas) {
+          runtime.schemas = schemas
+        }
+      }
+      if (fullMeta.data.inherit !== undefined) {
+        runtime.inheritData = fullMeta.data.inherit
+      }
     }
   }
 
-  // Param defaults - support both v2 'params' and v1 'properties'
-  const paramsObj = fullMeta.params || fullMeta.properties
+  const paramsObj = fullMeta.params
   const defaults = extractParamDefaults(paramsObj)
   if (defaults) {
     runtime.defaults = defaults
@@ -225,7 +246,8 @@ export function extractRuntimeSchema(fullMeta) {
 
   // Schemas - lean version for runtime validation/defaults
   // Strips editor-only fields (label, hint, description)
-  if (fullMeta.schemas) {
+  // Top-level schemas supported for backwards compat (lower priority than data.schemas)
+  if (fullMeta.schemas && !runtime.schemas) {
     const schemas = extractSchemas(fullMeta.schemas)
     if (schemas) {
       runtime.schemas = schemas
@@ -234,10 +256,17 @@ export function extractRuntimeSchema(fullMeta) {
 
   // Data inheritance - component receives cascaded data from page/site level fetches
   // Can be: true (inherit all), false (inherit none), or ['schema1', 'schema2'] (selective)
-  if (fullMeta.inheritData !== undefined) {
+  // Top-level inheritData supported for backwards compat (lower priority than data.inherit)
+  if (fullMeta.inheritData !== undefined && runtime.inheritData === undefined) {
     runtime.inheritData = fullMeta.inheritData
   }
 
+  // Auto-derive inheritData from entity type when no explicit inherit is set.
+  // data: { entity: 'articles' } implies inheritData: ['articles']
+  if (runtime.data && runtime.inheritData === undefined) {
+    runtime.inheritData = [runtime.data.type]
+  }
+
   return Object.keys(runtime).length > 0 ? runtime : null
 }
 

package/src/schema.js

@@ -3,12 +3,18 @@
  *
  * Discovers component meta files and loads them for schema.json generation.
  * Schema data is for editor-time only, not runtime.
+ *
+ * Discovery rules:
+ * - sections/ root: bare files and folders are addressable by default (implicit empty meta)
+ * - sections/ nested: meta.js required for addressability
+ * - components/ (and other paths): meta.js required (backward compatibility)
  */
 
 import { readdir, readFile } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
-import { join, dirname } from 'node:path'
+import { join, dirname, extname, basename } from 'node:path'
 import { pathToFileURL } from 'node:url'
+import { inferTitle } from './utils/infer-title.js'
 
 // Component meta file name
 const META_FILE_NAME = 'meta.js'
@@ -16,8 +22,15 @@ const META_FILE_NAME = 'meta.js'
 // Foundation config file name
 const FOUNDATION_FILE_NAME = 'foundation.js'
 
-// Default component paths (relative to srcDir)
-const DEFAULT_COMPONENT_PATHS = ['components']
+// Default paths to scan for content interfaces (relative to srcDir)
+// sections/ is the primary convention; components/ supported for backward compatibility
+const DEFAULT_COMPONENT_PATHS = ['sections', 'components']
+
+// Extensions recognized as component entry files
+const COMPONENT_EXTENSIONS = new Set(['.jsx', '.tsx', '.js', '.ts'])
+
+// The primary sections path where relaxed discovery applies
+const SECTIONS_PATH = 'sections'
 
 /**
  * Load a meta.js file via dynamic import
@@ -113,12 +126,173 @@ export async function loadFoundationMeta(srcDir) {
 }
 
 /**
- * Discover components in a single path
+ * Check if a filename looks like a PascalCase component (starts with uppercase)
+ */
+function isComponentFileName(name) {
+  return /^[A-Z]/.test(name)
+}
+
+/**
+ * Check if a directory has a valid entry file (Name.ext or index.ext)
+ */
+function hasEntryFile(dirPath, dirName) {
+  for (const ext of ['.jsx', '.tsx', '.js', '.ts']) {
+    if (existsSync(join(dirPath, `${dirName}${ext}`))) return true
+    if (existsSync(join(dirPath, `index${ext}`))) return true
+  }
+  return false
+}
+
+/**
+ * Create an implicit empty meta for a section type discovered without meta.js
+ */
+function createImplicitMeta(name) {
+  return { title: inferTitle(name) }
+}
+
+/**
+ * Build a component entry with title inference applied
+ */
+function buildComponentEntry(name, relativePath, meta) {
+  const entry = {
+    name,
+    path: relativePath,
+    ...meta,
+  }
+  // Apply title inference if meta has no explicit title
+  if (!entry.title) {
+    entry.title = inferTitle(name)
+  }
+  return entry
+}
+
+/**
+ * Discover section types in sections/ with relaxed rules
+ *
+ * Root level: bare files and folders are addressable by default.
+ * Nested levels: meta.js required for addressability.
+ *
  * @param {string} srcDir - Source directory (e.g., 'src')
- * @param {string} relativePath - Path relative to srcDir (e.g., 'components' or 'components/sections')
+ * @param {string} sectionsRelPath - Relative path to sections dir (e.g., 'sections')
+ */
+async function discoverSectionsInPath(srcDir, sectionsRelPath) {
+  const fullPath = join(srcDir, sectionsRelPath)
+
+  if (!existsSync(fullPath)) {
+    return {}
+  }
+
+  const entries = await readdir(fullPath, { withFileTypes: true })
+  const components = {}
+
+  // Collect names from both files and directories to detect collisions
+  const fileNames = new Set()
+  const dirNames = new Set()
+
+  for (const entry of entries) {
+    const ext = extname(entry.name)
+    if (entry.isFile() && COMPONENT_EXTENSIONS.has(ext)) {
+      const name = basename(entry.name, ext)
+      if (isComponentFileName(name)) {
+        fileNames.add(name)
+      }
+    } else if (entry.isDirectory()) {
+      dirNames.add(entry.name)
+    }
+  }
+
+  // Check for name collisions (e.g., Hero.jsx AND Hero/)
+  for (const name of fileNames) {
+    if (dirNames.has(name)) {
+      throw new Error(
+        `Name collision in ${sectionsRelPath}/: both "${name}.jsx" (or similar) and "${name}/" exist. ` +
+        `Use one or the other, not both.`
+      )
+    }
+  }
+
+  // Discover bare files at root
+  for (const entry of entries) {
+    if (!entry.isFile()) continue
+    const ext = extname(entry.name)
+    if (!COMPONENT_EXTENSIONS.has(ext)) continue
+    const name = basename(entry.name, ext)
+    if (!isComponentFileName(name)) continue
+
+    const meta = createImplicitMeta(name)
+    components[name] = {
+      ...buildComponentEntry(name, sectionsRelPath, meta),
+      // Bare file: the entry file IS the file itself (not inside a subdirectory)
+      entryFile: entry.name,
+    }
+  }
+
+  // Discover directories at root
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    if (!isComponentFileName(entry.name)) continue
+
+    const dirPath = join(fullPath, entry.name)
+    const relativePath = join(sectionsRelPath, entry.name)
+    const result = await loadComponentMeta(dirPath)
+
+    if (result && result.meta) {
+      // Has meta.js — use explicit meta
+      if (result.meta.exposed === false) continue
+      components[entry.name] = buildComponentEntry(entry.name, relativePath, result.meta)
+    } else if (hasEntryFile(dirPath, entry.name)) {
+      // No meta.js but has entry file — implicit section type at root
+      components[entry.name] = buildComponentEntry(entry.name, relativePath, createImplicitMeta(entry.name))
+    }
+
+    // Recurse into subdirectories for nested section types (meta.js required)
+    await discoverNestedSections(srcDir, dirPath, relativePath, components)
+  }
+
+  return components
+}
+
+/**
+ * Recursively discover nested section types that have meta.js
+ *
+ * @param {string} srcDir - Source directory
+ * @param {string} parentFullPath - Absolute path to parent directory
+ * @param {string} parentRelPath - Relative path from srcDir to parent
+ * @param {Object} components - Accumulator for discovered components
+ */
+async function discoverNestedSections(srcDir, parentFullPath, parentRelPath, components) {
+  let entries
+  try {
+    entries = await readdir(parentFullPath, { withFileTypes: true })
+  } catch {
+    return
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+
+    const dirPath = join(parentFullPath, entry.name)
+    const relativePath = join(parentRelPath, entry.name)
+    const result = await loadComponentMeta(dirPath)
+
+    if (result && result.meta) {
+      if (result.meta.exposed === false) continue
+      components[entry.name] = buildComponentEntry(entry.name, relativePath, result.meta)
+    }
+
+    // Continue recursing regardless — deeper levels may have meta.js
+    await discoverNestedSections(srcDir, dirPath, relativePath, components)
+  }
+}
+
+/**
+ * Discover components in a non-sections path (meta.js required)
+ *
+ * @param {string} srcDir - Source directory (e.g., 'src')
+ * @param {string} relativePath - Path relative to srcDir (e.g., 'components')
  * @returns {Object} Map of componentName -> { name, path, ...meta }
  */
-async function discoverComponentsInPath(srcDir, relativePath) {
+async function discoverExplicitComponentsInPath(srcDir, relativePath) {
   const fullPath = join(srcDir, relativePath)
 
   if (!existsSync(fullPath)) {
@@ -135,16 +309,12 @@ async function discoverComponentsInPath(srcDir, relativePath) {
     const result = await loadComponentMeta(componentDir)
 
     if (result && result.meta) {
-      // Check if explicitly not exposed
+      // Check if explicitly hidden from discovery
       if (result.meta.exposed === false) {
         continue
       }
 
-      components[entry.name] = {
-        name: entry.name,
-        path: join(relativePath, entry.name), // e.g., 'components/Hero' or 'components/sections/Hero'
-        ...result.meta,
-      }
+      components[entry.name] = buildComponentEntry(entry.name, join(relativePath, entry.name), result.meta)
     }
   }
 
@@ -152,18 +322,25 @@ async function discoverComponentsInPath(srcDir, relativePath) {
 }
 
 /**
- * Discover all exposed components in a foundation
+ * Discover all section types in a foundation
+ *
+ * For the 'sections' path: relaxed discovery (bare files and folders at root,
+ * meta.js required for nested levels).
+ * For other paths: strict discovery (meta.js required).
  *
  * @param {string} srcDir - Source directory (e.g., 'src')
- * @param {string[]} [componentPaths] - Paths to search for components (relative to srcDir)
- *                                      Default: ['components']
- * @returns {Object} Map of componentName -> { name, path, ...meta }
+ * @param {string[]} [componentPaths] - Paths to scan for section types (relative to srcDir).
+ *                                      Default: ['sections', 'components']
+ * @returns {Object} Map of sectionTypeName -> { name, path, ...meta }
  */
 export async function discoverComponents(srcDir, componentPaths = DEFAULT_COMPONENT_PATHS) {
   const components = {}
 
   for (const relativePath of componentPaths) {
-    const found = await discoverComponentsInPath(srcDir, relativePath)
+    // Use relaxed discovery for the primary sections path
+    const found = relativePath === SECTIONS_PATH
+      ? await discoverSectionsInPath(srcDir, relativePath)
+      : await discoverExplicitComponentsInPath(srcDir, relativePath)
 
     for (const [name, meta] of Object.entries(found)) {
       if (components[name]) {
@@ -210,10 +387,10 @@ export async function buildSchema(srcDir, componentPaths) {
 }
 
 /**
- * Get list of exposed component names
+ * Get list of section type names
  *
  * @param {string} srcDir - Source directory
- * @param {string[]} [componentPaths] - Paths to search for components
+ * @param {string[]} [componentPaths] - Paths to scan for section types
  */
 export async function getExposedComponents(srcDir, componentPaths) {
   const components = await discoverComponents(srcDir, componentPaths)