@uniweb/runtime 0.1.1 → 0.2.1

package/src/vite/content-collector.js

@@ -1,269 +0,0 @@
-/**
- * Content Collector for Vite
- *
- * Collects site content from a pages/ directory structure:
- * - site.yml: Site configuration
- * - pages/: Directory of page folders
- *   - page.yml: Page metadata
- *   - *.md: Section content with YAML frontmatter
- *
- * Uses @uniweb/content-reader for markdown → ProseMirror conversion
- * when available, otherwise uses a simplified parser.
- */
-
-import { readFile, readdir, stat } from 'node:fs/promises'
-import { join, parse, relative } from 'node:path'
-import { existsSync } from 'node:fs'
-import yaml from 'js-yaml'
-
-// Try to import content-reader, fall back to simplified parser
-let markdownToProseMirror
-try {
-  const contentReader = await import('@uniweb/content-reader')
-  markdownToProseMirror = contentReader.markdownToProseMirror
-} catch {
-  // Simplified fallback - just wraps content as text
-  markdownToProseMirror = (markdown) => ({
-    type: 'doc',
-    content: [
-      {
-        type: 'paragraph',
-        content: [{ type: 'text', text: markdown.trim() }]
-      }
-    ]
-  })
-}
-
-/**
- * Parse YAML string using js-yaml
- */
-function parseYaml(yamlString) {
-  try {
-    return yaml.load(yamlString) || {}
-  } catch (err) {
-    console.warn('[content-collector] YAML parse error:', err.message)
-    return {}
-  }
-}
-
-/**
- * Read and parse a YAML file
- */
-async function readYamlFile(filePath) {
-  try {
-    const content = await readFile(filePath, 'utf8')
-    return parseYaml(content)
-  } catch (err) {
-    if (err.code === 'ENOENT') return {}
-    throw err
-  }
-}
-
-/**
- * Check if a file is a markdown file
- */
-function isMarkdownFile(filename) {
-  return filename.endsWith('.md') && !filename.startsWith('_')
-}
-
-/**
- * Parse numeric prefix from filename (e.g., "1-hero.md" → { prefix: "1", name: "hero" })
- */
-function parseNumericPrefix(filename) {
-  const match = filename.match(/^(\d+(?:\.\d+)*)-?(.*)$/)
-  if (match) {
-    return { prefix: match[1], name: match[2] || match[1] }
-  }
-  return { prefix: null, name: filename }
-}
-
-/**
- * Compare filenames for sorting by numeric prefix
- */
-function compareFilenames(a, b) {
-  const { prefix: prefixA } = parseNumericPrefix(parse(a).name)
-  const { prefix: prefixB } = parseNumericPrefix(parse(b).name)
-
-  if (!prefixA && !prefixB) return a.localeCompare(b)
-  if (!prefixA) return 1
-  if (!prefixB) return -1
-
-  const partsA = prefixA.split('.').map(Number)
-  const partsB = prefixB.split('.').map(Number)
-
-  for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
-    const numA = partsA[i] ?? 0
-    const numB = partsB[i] ?? 0
-    if (numA !== numB) return numA - numB
-  }
-
-  return 0
-}
-
-/**
- * Process a markdown file into a section
- */
-async function processMarkdownFile(filePath, id) {
-  const content = await readFile(filePath, 'utf8')
-  let frontMatter = {}
-  let markdown = content
-
-  // Extract frontmatter
-  if (content.trim().startsWith('---')) {
-    const parts = content.split('---\n')
-    if (parts.length >= 3) {
-      frontMatter = parseYaml(parts[1])
-      markdown = parts.slice(2).join('---\n')
-    }
-  }
-
-  const { component, preset, input, props, ...params } = frontMatter
-
-  // Convert markdown to ProseMirror
-  const proseMirrorContent = markdownToProseMirror(markdown)
-
-  return {
-    id,
-    component: component || 'Section',
-    preset,
-    input,
-    params: { ...params, ...props },
-    content: proseMirrorContent,
-    subsections: []
-  }
-}
-
-/**
- * Build section hierarchy from flat list
- */
-function buildSectionHierarchy(sections) {
-  const sectionMap = new Map()
-  const topLevel = []
-
-  // First pass: create map
-  for (const section of sections) {
-    sectionMap.set(section.id, section)
-  }
-
-  // Second pass: build hierarchy
-  for (const section of sections) {
-    if (!section.id.includes('.')) {
-      topLevel.push(section)
-      continue
-    }
-
-    const parts = section.id.split('.')
-    const parentId = parts.slice(0, -1).join('.')
-    const parent = sectionMap.get(parentId)
-
-    if (parent) {
-      parent.subsections.push(section)
-    } else {
-      // Orphan subsection - add to top level
-      topLevel.push(section)
-    }
-  }
-
-  return topLevel
-}
-
-/**
- * Process a page directory
- */
-async function processPage(pagePath, pageName, headerSections, footerSections) {
-  const pageConfig = await readYamlFile(join(pagePath, 'page.yml'))
-
-  if (pageConfig.hidden) return null
-
-  // Get markdown files
-  const files = await readdir(pagePath)
-  const mdFiles = files.filter(isMarkdownFile).sort(compareFilenames)
-
-  // Process sections
-  const sections = []
-  for (const file of mdFiles) {
-    const { name } = parse(file)
-    const { prefix } = parseNumericPrefix(name)
-    const id = prefix || name
-
-    const section = await processMarkdownFile(join(pagePath, file), id)
-    sections.push(section)
-  }
-
-  // Build hierarchy
-  const hierarchicalSections = buildSectionHierarchy(sections)
-
-  // Determine route
-  let route = '/' + pageName
-  if (pageName === 'home' || pageName === 'index') {
-    route = '/'
-  } else if (pageName.startsWith('@')) {
-    route = '/' + pageName
-  }
-
-  return {
-    route,
-    title: pageConfig.title || pageName,
-    description: pageConfig.description || '',
-    order: pageConfig.order,
-    sections: hierarchicalSections
-  }
-}
-
-/**
- * Collect all site content
- */
-export async function collectSiteContent(sitePath) {
-  const pagesPath = join(sitePath, 'pages')
-
-  // Read site config
-  const siteConfig = await readYamlFile(join(sitePath, 'site.yml'))
-  const themeConfig = await readYamlFile(join(sitePath, 'theme.yml'))
-
-  // Check if pages directory exists
-  if (!existsSync(pagesPath)) {
-    return {
-      config: siteConfig,
-      theme: themeConfig,
-      pages: []
-    }
-  }
-
-  // Get page directories
-  const entries = await readdir(pagesPath)
-  const pages = []
-  let header = null
-  let footer = null
-
-  for (const entry of entries) {
-    const entryPath = join(pagesPath, entry)
-    const stats = await stat(entryPath)
-
-    if (!stats.isDirectory()) continue
-
-    const page = await processPage(entryPath, entry)
-    if (!page) continue
-
-    // Handle special pages
-    if (entry === '@header' || page.route === '/@header') {
-      header = page
-    } else if (entry === '@footer' || page.route === '/@footer') {
-      footer = page
-    } else {
-      pages.push(page)
-    }
-  }
-
-  // Sort pages by order
-  pages.sort((a, b) => (a.order ?? 999) - (b.order ?? 999))
-
-  return {
-    config: siteConfig,
-    theme: themeConfig,
-    pages,
-    header,
-    footer
-  }
-}
-
-export default collectSiteContent

package/src/vite/foundation-plugin.js

@@ -1,194 +0,0 @@
-/**
- * Vite Plugin: Foundation
- *
- * Builds and serves a foundation within the site's dev server.
- * This enables a single dev server for both site and foundation development.
- *
- * Usage:
- * ```js
- * import { foundationPlugin } from '@uniweb/runtime/vite'
- *
- * export default defineConfig({
- *   plugins: [
- *     foundationPlugin({
- *       name: 'my-foundation',
- *       path: '../my-foundation',  // Path to foundation package
- *       serve: '/foundation',      // URL path to serve from
- *     })
- *   ]
- * })
- * ```
- */
-
-import { resolve, join, relative } from 'node:path'
-import { watch } from 'node:fs'
-import { readFile, readdir, stat } from 'node:fs/promises'
-import { existsSync } from 'node:fs'
-import { build } from 'vite'
-
-/**
- * Create the foundation plugin
- */
-export function foundationPlugin(options = {}) {
-  const {
-    name = 'foundation',
-    path: foundationPath = '../foundation',
-    serve: servePath = '/foundation',
-    watch: shouldWatch = true,
-    buildOnStart = true
-  } = options
-
-  let resolvedFoundationPath = null
-  let resolvedDistPath = null
-  let server = null
-  let watcher = null
-  let isBuilding = false
-  let lastBuildTime = 0
-
-  /**
-   * Build the foundation using Vite
-   */
-  async function buildFoundation() {
-    if (isBuilding) return
-    isBuilding = true
-
-    const startTime = Date.now()
-    console.log(`[foundation] Building ${name}...`)
-
-    try {
-      // Use Vite's native config loading by specifying configFile
-      const configPath = join(resolvedFoundationPath, 'vite.config.js')
-
-      // Build using Vite with the foundation's own config file
-      await build({
-        root: resolvedFoundationPath,
-        configFile: existsSync(configPath) ? configPath : false,
-        logLevel: 'warn',
-        build: {
-          outDir: 'dist',
-          emptyOutDir: true,
-          watch: null, // Don't use Vite's watch, we handle it ourselves
-        },
-      })
-
-      lastBuildTime = Date.now()
-      console.log(`[foundation] Built ${name} in ${lastBuildTime - startTime}ms`)
-
-      // Trigger HMR reload if server is running
-      if (server) {
-        server.ws.send({ type: 'full-reload' })
-      }
-    } catch (err) {
-      console.error(`[foundation] Build failed:`, err.message)
-    } finally {
-      isBuilding = false
-    }
-  }
-
-  return {
-    name: 'uniweb:foundation',
-    // Run before other plugins to intercept foundation requests
-    enforce: 'pre',
-
-    configResolved(config) {
-      resolvedFoundationPath = resolve(config.root, foundationPath)
-      resolvedDistPath = join(resolvedFoundationPath, 'dist')
-    },
-
-    async buildStart() {
-      if (buildOnStart) {
-        await buildFoundation()
-      }
-    },
-
-    configureServer(devServer) {
-      server = devServer
-
-      // Serve foundation files via middleware
-      // For JS files, use Vite's transform pipeline to properly resolve imports
-      devServer.middlewares.use(async (req, res, next) => {
-        const urlPath = req.url.split('?')[0]
-
-        if (!urlPath.startsWith(servePath)) {
-          return next()
-        }
-
-        const filePath = urlPath.slice(servePath.length) || '/foundation.js'
-        const fullPath = join(resolvedDistPath, filePath)
-
-        if (!existsSync(fullPath)) {
-          return next()
-        }
-
-        try {
-          let content = await readFile(fullPath, 'utf-8')
-          let contentType = 'application/octet-stream'
-
-          if (filePath.endsWith('.js')) {
-            contentType = 'application/javascript'
-
-            // Use Vite's transform pipeline to resolve bare imports
-            // This properly handles React ESM/CJS interop
-            const result = await devServer.transformRequest(
-              `/@fs${fullPath}`,
-              { html: false }
-            )
-
-            if (result) {
-              content = result.code
-            }
-          } else if (filePath.endsWith('.css')) {
-            contentType = 'text/css'
-          } else if (filePath.endsWith('.json')) {
-            contentType = 'application/json'
-          }
-
-          res.setHeader('Content-Type', contentType)
-          res.setHeader('Cache-Control', 'no-cache')
-          res.setHeader('Access-Control-Allow-Origin', '*')
-          res.end(content)
-        } catch (err) {
-          next(err)
-        }
-      })
-
-      // Watch foundation source for changes
-      if (shouldWatch) {
-        const srcPath = join(resolvedFoundationPath, 'src')
-
-        // Debounce rebuilds
-        let rebuildTimeout = null
-        const scheduleRebuild = () => {
-          if (rebuildTimeout) clearTimeout(rebuildTimeout)
-          rebuildTimeout = setTimeout(() => {
-            buildFoundation()
-          }, 200)
-        }
-
-        try {
-          watcher = watch(srcPath, { recursive: true }, (eventType, filename) => {
-            // Ignore non-source files
-            if (filename && (filename.endsWith('.js') || filename.endsWith('.jsx') ||
-                filename.endsWith('.ts') || filename.endsWith('.tsx') ||
-                filename.endsWith('.css') || filename.endsWith('.svg'))) {
-              console.log(`[foundation] ${filename} changed`)
-              scheduleRebuild()
-            }
-          })
-          console.log(`[foundation] Watching ${srcPath}`)
-        } catch (err) {
-          console.warn(`[foundation] Could not watch source:`, err.message)
-        }
-      }
-    },
-
-    closeBundle() {
-      if (watcher) {
-        watcher.close()
-        watcher = null
-      }
-    }
-  }
-}
-
-export default foundationPlugin

package/src/vite/index.js

@@ -1,7 +0,0 @@
-/**
- * Vite plugins for @uniweb/runtime
- */
-
-export { siteContentPlugin } from './site-content-plugin.js'
-export { collectSiteContent } from './content-collector.js'
-export { foundationPlugin } from './foundation-plugin.js'

package/src/vite/site-content-plugin.js

@@ -1,135 +0,0 @@
-/**
- * Vite Plugin: Site Content
- *
- * Collects site content from pages/ directory and injects it into HTML.
- * Watches for changes in development mode.
- *
- * Usage:
- * ```js
- * import { siteContentPlugin } from '@uniweb/runtime/vite'
- *
- * export default defineConfig({
- *   plugins: [
- *     siteContentPlugin({
- *       sitePath: './site',  // Path to site directory
- *       inject: true,        // Inject into HTML
- *     })
- *   ]
- * })
- * ```
- */
-
-import { resolve } from 'node:path'
-import { watch } from 'node:fs'
-import { collectSiteContent } from './content-collector.js'
-
-/**
- * Create the site content plugin
- */
-export function siteContentPlugin(options = {}) {
-  const {
-    sitePath = './',
-    pagesDir = 'pages',
-    variableName = '__SITE_CONTENT__',
-    inject = true,
-    filename = 'site-content.json',
-    watch: shouldWatch = true
-  } = options
-
-  let siteContent = null
-  let resolvedSitePath = null
-  let watcher = null
-  let server = null
-
-  return {
-    name: 'uniweb:site-content',
-
-    configResolved(config) {
-      resolvedSitePath = resolve(config.root, sitePath)
-    },
-
-    async buildStart() {
-      // Collect content at build start
-      try {
-        siteContent = await collectSiteContent(resolvedSitePath)
-        console.log(`[site-content] Collected ${siteContent.pages?.length || 0} pages`)
-      } catch (err) {
-        console.error('[site-content] Failed to collect content:', err.message)
-        siteContent = { config: {}, theme: {}, pages: [] }
-      }
-    },
-
-    configureServer(devServer) {
-      server = devServer
-
-      // Watch for content changes in dev mode
-      if (shouldWatch) {
-        const watchPath = resolve(resolvedSitePath, pagesDir)
-
-        // Debounce rebuilds
-        let rebuildTimeout = null
-        const scheduleRebuild = () => {
-          if (rebuildTimeout) clearTimeout(rebuildTimeout)
-          rebuildTimeout = setTimeout(async () => {
-            console.log('[site-content] Content changed, rebuilding...')
-            try {
-              siteContent = await collectSiteContent(resolvedSitePath)
-              console.log(`[site-content] Rebuilt ${siteContent.pages?.length || 0} pages`)
-
-              // Send full reload to client
-              server.ws.send({ type: 'full-reload' })
-            } catch (err) {
-              console.error('[site-content] Rebuild failed:', err.message)
-            }
-          }, 100)
-        }
-
-        try {
-          watcher = watch(watchPath, { recursive: true }, scheduleRebuild)
-          console.log(`[site-content] Watching ${watchPath}`)
-        } catch (err) {
-          console.warn('[site-content] Could not watch pages directory:', err.message)
-        }
-      }
-
-      // Serve content as JSON endpoint
-      devServer.middlewares.use((req, res, next) => {
-        if (req.url === `/${filename}`) {
-          res.setHeader('Content-Type', 'application/json')
-          res.end(JSON.stringify(siteContent, null, 2))
-          return
-        }
-        next()
-      })
-    },
-
-    transformIndexHtml(html) {
-      if (!inject || !siteContent) return html
-
-      // Inject content as JSON script tag
-      const injection = `<script type="application/json" id="${variableName}">${JSON.stringify(siteContent)}</script>\n`
-
-      // Insert before </head>
-      return html.replace('</head>', injection + '</head>')
-    },
-
-    generateBundle() {
-      // Emit content as JSON file in production build
-      this.emitFile({
-        type: 'asset',
-        fileName: filename,
-        source: JSON.stringify(siteContent, null, 2)
-      })
-    },
-
-    closeBundle() {
-      // Clean up watcher
-      if (watcher) {
-        watcher.close()
-        watcher = null
-      }
-    }
-  }
-}
-
-export default siteContentPlugin