@uniweb/build 0.1.26 → 0.1.28

package/src/runtime-schema.js

@@ -10,6 +10,7 @@
  * - defaults: param default values
  * - context: static capabilities for cross-block coordination
  * - initialState: initial values for mutable block state
+ * - inheritData: boolean or array for cascaded data from page/site fetches
  *
  * Full metadata (titles, descriptions, hints, etc.) stays in schema.json
  * for the visual editor.
@@ -35,6 +36,125 @@ function parseDataString(dataString) {
   }
 }
 
+/**
+ * Extract lean schema field for runtime
+ * Strips editor-only fields (label, hint, description)
+ * Keeps runtime fields (type, default, options, of, schema)
+ *
+ * @param {string|Object} field - Schema field definition
+ * @returns {string|Object} - Lean field definition
+ */
+function extractSchemaField(field) {
+  // Shorthand: 'string', 'number', 'boolean'
+  if (typeof field === 'string') {
+    return field
+  }
+
+  if (!field || typeof field !== 'object') {
+    return field
+  }
+
+  const lean = {}
+
+  // Keep runtime-relevant fields
+  if (field.type) lean.type = field.type
+  if (field.default !== undefined) lean.default = field.default
+  if (field.options) lean.options = field.options
+
+  // Handle array 'of' - can be string, schema name, or inline object
+  if (field.of !== undefined) {
+    if (typeof field.of === 'string') {
+      lean.of = field.of
+    } else if (typeof field.of === 'object') {
+      // Inline schema definition
+      lean.of = extractSchemaFields(field.of)
+    }
+  }
+
+  // Handle nested object 'schema'
+  if (field.schema && typeof field.schema === 'object') {
+    lean.schema = extractSchemaFields(field.schema)
+  }
+
+  // If we only have 'type' and it's a simple type, use shorthand
+  const keys = Object.keys(lean)
+  if (keys.length === 1 && keys[0] === 'type' && ['string', 'number', 'boolean'].includes(lean.type)) {
+    return lean.type
+  }
+
+  return keys.length > 0 ? lean : null
+}
+
+/**
+ * Extract lean schema fields for an entire schema object
+ *
+ * @param {Object} schemaFields - Map of fieldName -> field definition
+ * @returns {Object} - Map of fieldName -> lean field definition
+ */
+function extractSchemaFields(schemaFields) {
+  if (!schemaFields || typeof schemaFields !== 'object') {
+    return {}
+  }
+
+  const lean = {}
+  for (const [name, field] of Object.entries(schemaFields)) {
+    const leanField = extractSchemaField(field)
+    if (leanField !== null) {
+      lean[name] = leanField
+    }
+  }
+  return lean
+}
+
+/**
+ * Check if a schema value is in the full @uniweb/schemas format
+ * Full format has: { name, version?, description?, fields: {...} }
+ *
+ * @param {Object} schema - Schema value to check
+ * @returns {boolean}
+ */
+function isFullSchemaFormat(schema) {
+  return (
+    schema &&
+    typeof schema === 'object' &&
+    typeof schema.fields === 'object' &&
+    schema.fields !== null
+  )
+}
+
+/**
+ * Extract lean schemas from meta.js schemas object
+ * Strips editor-only fields while preserving structure
+ *
+ * Supports two formats:
+ * 1. Full @uniweb/schemas format: { name, version, fields: {...} }
+ * 2. Inline fields format: { fieldName: fieldDef, ... }
+ *
+ * @param {Object} schemas - The schemas object from meta.js
+ * @returns {Object|null} - Lean schemas or null if empty
+ */
+function extractSchemas(schemas) {
+  if (!schemas || typeof schemas !== 'object') {
+    return null
+  }
+
+  const lean = {}
+  for (const [schemaName, schemaValue] of Object.entries(schemas)) {
+    // Handle full schema format (from @uniweb/schemas or npm packages)
+    // Extract just the fields, discard name/version/description metadata
+    const schemaFields = isFullSchemaFormat(schemaValue)
+      ? schemaValue.fields
+      : schemaValue
+
+    const leanSchema = extractSchemaFields(schemaFields)
+    if (Object.keys(leanSchema).length > 0) {
+      lean[schemaName] = leanSchema
+    }
+  }
+
+  return Object.keys(lean).length > 0 ? lean : null
+}
+
 /**
  * Extract param defaults from params object
  *
@@ -102,6 +222,21 @@ export function extractRuntimeSchema(fullMeta) {
     runtime.initialState = fullMeta.initialState
   }
 
+  // Schemas - lean version for runtime validation/defaults
+  // Strips editor-only fields (label, hint, description)
+  if (fullMeta.schemas) {
+    const schemas = extractSchemas(fullMeta.schemas)
+    if (schemas) {
+      runtime.schemas = schemas
+    }
+  }
+
+  // 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) {
+    runtime.inheritData = fullMeta.inheritData
+  }
+
   return Object.keys(runtime).length > 0 ? runtime : null
 }
 

package/src/site/asset-processor.js

@@ -166,6 +166,33 @@ export async function processAssets(assetManifest, options = {}) {
   return { pathMapping, results }
 }
 
+/**
+ * Recursively rewrite asset paths in a data object
+ *
+ * @param {any} data - Parsed JSON/YAML data
+ * @param {Object} pathMapping - Map of original paths to new paths
+ * @returns {any} Data with rewritten paths
+ */
+function rewriteDataPaths(data, pathMapping) {
+  if (typeof data === 'string') {
+    return pathMapping[data] || data
+  }
+
+  if (Array.isArray(data)) {
+    return data.map(item => rewriteDataPaths(item, pathMapping))
+  }
+
+  if (data && typeof data === 'object') {
+    const result = {}
+    for (const [key, value] of Object.entries(data)) {
+      result[key] = rewriteDataPaths(value, pathMapping)
+    }
+    return result
+  }
+
+  return data
+}
+
 /**
  * Rewrite asset paths in ProseMirror content
  *
@@ -188,6 +215,11 @@ export function rewriteContentPaths(content, pathMapping) {
       }
     }
 
+    // Rewrite paths in data blocks (structured data parsed at build time)
+    if (node.type === 'dataBlock' && node.attrs?.data) {
+      node.attrs.data = rewriteDataPaths(node.attrs.data, pathMapping)
+    }
+
     // Recurse into content
     if (node.content && Array.isArray(node.content)) {
       node.content.forEach(walk)

package/src/site/assets.js

@@ -50,6 +50,72 @@ function isPdfPath(src) {
   return src.toLowerCase().endsWith(PDF_EXTENSION)
 }
 
+/**
+ * Check if a string looks like a local asset path
+ *
+ * @param {string} value - String to check
+ * @returns {boolean} True if it looks like a local asset path
+ */
+function isLocalAssetPath(value) {
+  if (typeof value !== 'string' || !value) return false
+
+  // Skip external URLs
+  if (isExternalUrl(value)) return false
+
+  // Must start with ./, ../, or / (absolute site path)
+  if (!value.startsWith('./') && !value.startsWith('../') && !value.startsWith('/')) {
+    return false
+  }
+
+  // Must have a media extension
+  return isImagePath(value) || isVideoPath(value) || isPdfPath(value)
+}
+
+/**
+ * Recursively walk a parsed data object and collect asset paths
+ *
+ * @param {any} data - Parsed JSON/YAML data
+ * @param {Function} visitor - Callback for each asset path: (path) => void
+ */
+function walkDataAssets(data, visitor) {
+  if (typeof data === 'string') {
+    if (isLocalAssetPath(data)) {
+      visitor(data)
+    }
+    return
+  }
+
+  if (Array.isArray(data)) {
+    data.forEach(item => walkDataAssets(item, visitor))
+    return
+  }
+
+  if (data && typeof data === 'object') {
+    Object.values(data).forEach(value => walkDataAssets(value, visitor))
+  }
+}
+
+/**
+ * Walk ProseMirror content and collect assets from data blocks
+ * Data blocks have pre-parsed structured data (parsed at content-reader build time)
+ *
+ * @param {Object} doc - ProseMirror document
+ * @param {Function} visitor - Callback for each asset: (path) => void
+ */
+function walkDataBlockAssets(doc, visitor) {
+  if (!doc) return
+
+  // dataBlock nodes have pre-parsed data in attrs.data
+  if (doc.type === 'dataBlock' && doc.attrs?.data) {
+    walkDataAssets(doc.attrs.data, visitor)
+  }
+
+  // Recurse into content
+  if (doc.content && Array.isArray(doc.content)) {
+    doc.content.forEach(child => walkDataBlockAssets(child, visitor))
+  }
+}
+
 /**
  * Resolve an asset path to absolute file system path
  *
@@ -215,6 +281,22 @@ export function collectSectionAssets(section, markdownPath, siteRoot) {
     }
   }
 
+  // Collect from tagged code blocks (JSON/YAML data)
+  if (section.content) {
+    walkDataBlockAssets(section.content, (assetPath) => {
+      const result = resolveAssetPath(assetPath, markdownPath, siteRoot)
+      if (!result.external && result.resolved) {
+        assets[assetPath] = {
+          original: assetPath,
+          resolved: result.resolved,
+          isImage: result.isImage,
+          isVideo: result.isVideo,
+          isPdf: result.isPdf
+        }
+      }
+    })
+  }
+
   return { assets, hasExplicitPoster, hasExplicitPreview }
 }
 

package/src/site/collection-processor.js

@@ -0,0 +1,382 @@
+/**
+ * Collection Processor
+ *
+ * Processes content collections from markdown files into JSON data.
+ * Collections are defined in site.yml and processed at build time.
+ *
+ * Features:
+ * - Discovers markdown files in content folders
+ * - Parses frontmatter for metadata
+ * - Converts markdown body to ProseMirror JSON
+ * - Supports filtering, sorting, and limiting
+ * - Auto-generates excerpts and extracts first images
+ *
+ * @module @uniweb/build/site/collection-processor
+ *
+ * @example
+ * // site.yml
+ * collections:
+ *   articles:
+ *     path: content/articles
+ *     sort: date desc
+ *
+ * // Usage
+ * const collections = await processCollections(siteDir, config.collections)
+ * await writeCollectionFiles(siteDir, collections)
+ */
+
+import { readFile, readdir, stat, writeFile, mkdir } from 'node:fs/promises'
+import { join, basename, extname } from 'node:path'
+import { existsSync } from 'node:fs'
+import yaml from 'js-yaml'
+import { applyFilter, applySort } from './data-fetcher.js'
+
+// Try to import content-reader for markdown parsing
+let markdownToProseMirror
+try {
+  const contentReader = await import('@uniweb/content-reader')
+  markdownToProseMirror = contentReader.markdownToProseMirror
+} catch {
+  // Simplified fallback
+  markdownToProseMirror = (markdown) => ({
+    type: 'doc',
+    content: [
+      {
+        type: 'paragraph',
+        content: [{ type: 'text', text: markdown.trim() }]
+      }
+    ]
+  })
+}
+
+/**
+ * Parse collection config from site.yml
+ *
+ * @param {string} name - Collection name
+ * @param {string|Object} config - Simple path string or full config object
+ * @returns {Object} Normalized config
+ *
+ * @example
+ * // Simple form
+ * parseCollectionConfig('articles', 'content/articles')
+ *
+ * // Extended form
+ * parseCollectionConfig('articles', {
+ *   path: 'content/articles',
+ *   sort: 'date desc',
+ *   filter: 'published != false',
+ *   limit: 100
+ * })
+ */
+function parseCollectionConfig(name, config) {
+  if (typeof config === 'string') {
+    return {
+      name,
+      path: config,
+      sort: null,
+      filter: null,
+      limit: 0,
+      excerpt: { maxLength: 160 }
+    }
+  }
+
+  return {
+    name,
+    path: config.path,
+    sort: config.sort || null,
+    filter: config.filter || null,
+    limit: config.limit || 0,
+    excerpt: {
+      maxLength: config.excerpt?.maxLength || 160,
+      field: config.excerpt?.field || null
+    }
+  }
+}
+
+/**
+ * Parse YAML frontmatter from markdown content
+ *
+ * @param {string} raw - Raw file content
+ * @returns {{ frontmatter: Object, body: string }}
+ */
+function parseFrontmatter(raw) {
+  if (!raw.trim().startsWith('---')) {
+    return { frontmatter: {}, body: raw }
+  }
+
+  const parts = raw.split('---\n')
+  if (parts.length < 3) {
+    return { frontmatter: {}, body: raw }
+  }
+
+  try {
+    const frontmatter = yaml.load(parts[1]) || {}
+    const body = parts.slice(2).join('---\n')
+    return { frontmatter, body }
+  } catch (err) {
+    console.warn('[collection-processor] YAML parse error:', err.message)
+    return { frontmatter: {}, body: raw }
+  }
+}
+
+/**
+ * Extract plain text from ProseMirror content
+ *
+ * @param {Object} node - ProseMirror node
+ * @returns {string} Plain text
+ */
+function extractPlainText(node) {
+  if (!node) return ''
+
+  if (node.type === 'text') {
+    return node.text || ''
+  }
+
+  if (Array.isArray(node.content)) {
+    return node.content.map(extractPlainText).join('')
+  }
+
+  return ''
+}
+
+/**
+ * Extract excerpt from content
+ *
+ * @param {Object} frontmatter - Parsed frontmatter
+ * @param {Object} content - ProseMirror content
+ * @param {Object} excerptConfig - Excerpt configuration
+ * @returns {string} Excerpt text
+ */
+function extractExcerpt(frontmatter, content, excerptConfig) {
+  const { maxLength = 160, field = null } = excerptConfig || {}
+
+  // Check for explicit excerpt in frontmatter
+  if (frontmatter.excerpt) {
+    return frontmatter.excerpt.slice(0, maxLength)
+  }
+
+  // Check for alternative field (e.g., 'description')
+  if (field && frontmatter[field]) {
+    return frontmatter[field].slice(0, maxLength)
+  }
+
+  // Auto-extract from content
+  const text = extractPlainText(content)
+  if (!text) return ''
+
+  // Clean and truncate
+  const cleaned = text.replace(/\s+/g, ' ').trim()
+  if (cleaned.length <= maxLength) return cleaned
+
+  // Truncate at word boundary
+  const truncated = cleaned.slice(0, maxLength)
+  const lastSpace = truncated.lastIndexOf(' ')
+  return lastSpace > maxLength * 0.7
+    ? truncated.slice(0, lastSpace) + '...'
+    : truncated + '...'
+}
+
+/**
+ * Extract first image from ProseMirror content
+ *
+ * @param {Object} node - ProseMirror node
+ * @returns {string|null} Image URL or null
+ */
+function extractFirstImage(node) {
+  if (!node) return null
+
+  if (node.type === 'image' && node.attrs?.src) {
+    return node.attrs.src
+  }
+
+  if (Array.isArray(node.content)) {
+    for (const child of node.content) {
+      const img = extractFirstImage(child)
+      if (img) return img
+    }
+  }
+
+  return null
+}
+
+// Filter and sort utilities are imported from data-fetcher.js
+
+/**
+ * Process a single content item from a markdown file
+ *
+ * @param {string} dir - Collection directory path
+ * @param {string} filename - Markdown filename
+ * @param {Object} config - Collection configuration
+ * @returns {Promise<Object|null>} Processed item or null if unpublished
+ */
+async function processContentItem(dir, filename, config) {
+  const filepath = join(dir, filename)
+  const raw = await readFile(filepath, 'utf-8')
+  const slug = basename(filename, extname(filename))
+
+  // Parse frontmatter and body
+  const { frontmatter, body } = parseFrontmatter(raw)
+
+  // Skip unpublished items by default
+  if (frontmatter.published === false) {
+    return null
+  }
+
+  // Parse markdown body to ProseMirror
+  const content = markdownToProseMirror(body)
+
+  // Extract excerpt
+  const excerpt = extractExcerpt(frontmatter, content, config.excerpt)
+
+  // Extract first image (frontmatter takes precedence)
+  const image = frontmatter.image || extractFirstImage(content)
+
+  // Get file stats for lastModified
+  const fileStat = await stat(filepath)
+
+  return {
+    slug,
+    ...frontmatter,
+    excerpt,
+    image,
+    // Include both raw markdown body (for simple rendering)
+    // and ProseMirror content (for rich rendering)
+    body: body.trim(),
+    content,
+    lastModified: fileStat.mtime.toISOString()
+  }
+}
+
+/**
+ * Collect and process all items in a collection folder
+ *
+ * @param {string} siteDir - Site root directory
+ * @param {Object} config - Parsed collection config
+ * @returns {Promise<Array>} Array of processed items
+ */
+async function collectItems(siteDir, config) {
+  const collectionDir = join(siteDir, config.path)
+
+  // Check if collection directory exists
+  if (!existsSync(collectionDir)) {
+    console.warn(`[collection-processor] Collection folder not found: ${config.path}`)
+    return []
+  }
+
+  const files = await readdir(collectionDir)
+  const mdFiles = files.filter(f => f.endsWith('.md') && !f.startsWith('_'))
+
+  // Process all markdown files
+  let items = await Promise.all(
+    mdFiles.map(file => processContentItem(collectionDir, file, config))
+  )
+
+  // Filter out nulls (unpublished items)
+  items = items.filter(Boolean)
+
+  // Apply custom filter
+  if (config.filter) {
+    items = applyFilter(items, config.filter)
+  }
+
+  // Apply sort
+  if (config.sort) {
+    items = applySort(items, config.sort)
+  }
+
+  // Apply limit
+  if (config.limit > 0) {
+    items = items.slice(0, config.limit)
+  }
+
+  return items
+}
+
+/**
+ * Process all content collections defined in site.yml
+ *
+ * @param {string} siteDir - Site root directory
+ * @param {Object} collectionsConfig - Collections config from site.yml
+ * @returns {Promise<Object>} Map of collection name to items array
+ *
+ * @example
+ * const collections = await processCollections('/path/to/site', {
+ *   articles: { path: 'content/articles', sort: 'date desc' },
+ *   products: 'content/products'
+ * })
+ * // { articles: [...], products: [...] }
+ */
+export async function processCollections(siteDir, collectionsConfig) {
+  if (!collectionsConfig || typeof collectionsConfig !== 'object') {
+    return {}
+  }
+
+  const results = {}
+
+  for (const [name, config] of Object.entries(collectionsConfig)) {
+    const parsed = parseCollectionConfig(name, config)
+    const items = await collectItems(siteDir, parsed)
+    results[name] = items
+    console.log(`[collection-processor] Processed ${name}: ${items.length} items`)
+  }
+
+  return results
+}
+
+/**
+ * Write collection data to JSON files in public/data/
+ *
+ * @param {string} siteDir - Site root directory
+ * @param {Object} collections - Map of collection name to items array
+ * @returns {Promise<void>}
+ *
+ * @example
+ * await writeCollectionFiles('/path/to/site', {
+ *   articles: [{ slug: 'hello', title: 'Hello World', ... }]
+ * })
+ * // Creates public/data/articles.json
+ */
+export async function writeCollectionFiles(siteDir, collections) {
+  if (!collections || Object.keys(collections).length === 0) {
+    return
+  }
+
+  const dataDir = join(siteDir, 'public', 'data')
+  await mkdir(dataDir, { recursive: true })
+
+  for (const [name, items] of Object.entries(collections)) {
+    const filepath = join(dataDir, `${name}.json`)
+    await writeFile(filepath, JSON.stringify(items, null, 2))
+    console.log(`[collection-processor] Generated ${filepath} (${items.length} items)`)
+  }
+}
+
+/**
+ * Get last modified time for a collection
+ *
+ * @param {string} siteDir - Site root directory
+ * @param {Object} config - Collection config
+ * @returns {Promise<Date|null>} Most recent modification time
+ */
+export async function getCollectionLastModified(siteDir, config) {
+  const parsed = parseCollectionConfig('temp', config)
+  const collectionDir = join(siteDir, parsed.path)
+
+  if (!existsSync(collectionDir)) {
+    return null
+  }
+
+  const files = await readdir(collectionDir)
+  const mdFiles = files.filter(f => f.endsWith('.md') && !f.startsWith('_'))
+
+  let lastModified = null
+
+  for (const file of mdFiles) {
+    const fileStat = await stat(join(collectionDir, file))
+    if (!lastModified || fileStat.mtime > lastModified) {
+      lastModified = fileStat.mtime
+    }
+  }
+
+  return lastModified
+}