@uniweb/runtime 0.1.1 → 0.2.1

package/src/core/block.js

@@ -1,311 +0,0 @@
-/**
- * Block
- *
- * Represents a section/block on a page. Contains content, properties,
- * child blocks, and state management. Connects to foundation components.
- */
-
-import { parseContent as parseSemanticContent } from '@uniweb/semantic-parser'
-
-export default class Block {
-  constructor(blockData, id) {
-    this.id = id
-    this.component = blockData.component || 'Section'
-    this.Component = null
-
-    // Content structure
-    // The content can be:
-    // 1. Raw ProseMirror content (from content collection)
-    // 2. Pre-parsed content with main/items structure
-    // For now, store raw and parse on demand
-    this.rawContent = blockData.content || {}
-    this.parsedContent = this.parseContent(blockData.content)
-
-    const { main, items } = this.parsedContent
-    this.main = main
-    this.items = items
-
-    // Block configuration
-    const blockConfig = blockData.params || blockData.config || {}
-    this.preset = blockData.preset
-    this.themeName = `context__${blockConfig.theme || 'light'}`
-    this.standardOptions = blockConfig.standardOptions || {}
-    this.properties = blockConfig.properties || blockConfig
-
-    // Child blocks (subsections)
-    this.childBlocks = blockData.subsections
-      ? blockData.subsections.map((block, i) => new Block(block, `${id}_${i}`))
-      : []
-
-    // Input data
-    this.input = blockData.input || null
-
-    // State management
-    this.startState = null
-    this.state = null
-    this.resetStateHook = null
-  }
-
-  /**
-   * Parse content into structured format using semantic-parser
-   * Supports multiple content formats:
-   * 1. Pre-parsed groups structure (from editor)
-   * 2. ProseMirror document (from markdown collection)
-   * 3. Simple key-value content (PoC style)
-   *
-   * Uses @uniweb/semantic-parser for rich content extraction including:
-   * - Pretitle detection (H3 before H1)
-   * - Banner/background image detection
-   * - Semantic grouping (main + items)
-   * - Lists, links, buttons, etc.
-   */
-  parseContent(content) {
-    // If content is already parsed with groups structure
-    if (content?.groups) {
-      return content.groups
-    }
-
-    // ProseMirror document - use semantic-parser
-    if (content?.type === 'doc') {
-      return this.extractFromProseMirror(content)
-    }
-
-    // Simple key-value content (PoC style) - pass through directly
-    // This allows components to receive content like { title, subtitle, items }
-    if (content && typeof content === 'object' && !Array.isArray(content)) {
-      return {
-        main: { header: {}, body: {} },
-        items: [],
-        // Store raw content for direct access
-        raw: content
-      }
-    }
-
-    // Fallback
-    return {
-      main: { header: {}, body: {} },
-      items: []
-    }
-  }
-
-  /**
-   * Extract structured content from ProseMirror document
-   * Uses @uniweb/semantic-parser for intelligent content extraction
-   */
-  extractFromProseMirror(doc) {
-    try {
-      // Parse with semantic-parser
-      const { groups, sequence, byType } = parseSemanticContent(doc)
-
-      // Transform groups structure to match expected format
-      const main = groups.main || { header: {}, body: {} }
-      const items = groups.items || []
-
-      return {
-        main,
-        items,
-        // Include additional data for advanced use cases
-        sequence,
-        byType,
-        metadata: groups.metadata
-      }
-    } catch (err) {
-      console.warn('[Block] Semantic parser error, using fallback:', err.message)
-      return this.extractFromProseMirrorFallback(doc)
-    }
-  }
-
-  /**
-   * Fallback extraction when semantic-parser fails
-   */
-  extractFromProseMirrorFallback(doc) {
-    const main = { header: {}, body: {} }
-    const items = []
-
-    if (!doc.content) return { main, items }
-
-    for (const node of doc.content) {
-      if (node.type === 'heading') {
-        const text = this.extractText(node)
-        if (node.attrs?.level === 1) {
-          main.header.title = text
-        } else if (node.attrs?.level === 2) {
-          main.header.subtitle = text
-        }
-      } else if (node.type === 'paragraph') {
-        const text = this.extractText(node)
-        if (!main.body.paragraphs) main.body.paragraphs = []
-        main.body.paragraphs.push(text)
-      }
-    }
-
-    return { main, items }
-  }
-
-  /**
-   * Extract text from a node
-   */
-  extractText(node) {
-    if (!node.content) return ''
-    return node.content
-      .filter((n) => n.type === 'text')
-      .map((n) => n.text)
-      .join('')
-  }
-
-  /**
-   * Initialize the component from the foundation
-   * @returns {React.ComponentType|null}
-   */
-  initComponent() {
-    if (this.Component) return this.Component
-
-    this.Component = globalThis.uniweb?.getComponent(this.component)
-
-    if (!this.Component) {
-      console.warn(`[Block] Component not found: ${this.component}`)
-      return null
-    }
-
-    // Initialize state from component defaults
-    const defaults = this.Component.blockDefaults || { state: this.Component.blockState }
-    this.startState = defaults.state ? { ...defaults.state } : null
-    this.initState()
-
-    return this.Component
-  }
-
-  /**
-   * Get structured block content for components
-   */
-  getBlockContent() {
-    const mainHeader = this.main?.header || {}
-    const mainBody = this.main?.body || {}
-    const banner = this.main?.banner || null
-
-    return {
-      banner,
-      pretitle: mainHeader.pretitle || '',
-      title: mainHeader.title || '',
-      subtitle: mainHeader.subtitle || '',
-      description: mainHeader.description || '',
-      paragraphs: mainBody.paragraphs || [],
-      images: mainBody.imgs || mainBody.images || [],
-      links: mainBody.links || [],
-      icons: mainBody.icons || [],
-      properties: mainBody.propertyBlocks?.[0] || {},
-      videos: mainBody.videos || [],
-      lists: mainBody.lists || [],
-      buttons: mainBody.buttons || []
-    }
-  }
-
-  /**
-   * Get block properties
-   */
-  getBlockProperties() {
-    return this.properties
-  }
-
-  /**
-   * Get child block renderer from runtime
-   */
-  getChildBlockRenderer() {
-    return globalThis.uniweb?.childBlockRenderer
-  }
-
-  /**
-   * Get links from block content
-   * @param {Object} options
-   * @returns {Array}
-   */
-  getBlockLinks(options = {}) {
-    const website = globalThis.uniweb?.activeWebsite
-
-    if (options.nested) {
-      const lists = this.main?.body?.lists || []
-      const links = lists[0]
-      return Block.parseNestedLinks(links, website)
-    }
-
-    const links = this.main?.body?.links || []
-    return links.map((link) => ({
-      route: website?.makeHref(link.href) || link.href,
-      label: link.label
-    }))
-  }
-
-  /**
-   * Initialize block state
-   */
-  initState() {
-    this.state = this.startState
-    if (this.resetStateHook) this.resetStateHook()
-  }
-
-  /**
-   * React hook for block state management
-   * @param {Function} useState - React useState hook
-   * @param {any} initState - Initial state
-   * @returns {[any, Function]}
-   */
-  useBlockState(useState, initState) {
-    if (initState !== undefined && this.startState === null) {
-      this.startState = initState
-      this.state = initState
-    } else {
-      initState = this.startState
-    }
-
-    const [state, setState] = useState(initState)
-
-    this.resetStateHook = () => setState(initState)
-
-    return [state, (newState) => setState((this.state = newState))]
-  }
-
-  /**
-   * Parse nested links structure
-   */
-  static parseNestedLinks(list, website) {
-    const parsed = []
-
-    if (!list?.length) return parsed
-
-    for (const listItem of list) {
-      const { links = [], lists = [], paragraphs = [] } = listItem
-
-      const link = links[0]
-      const nestedList = lists[0]
-      const text = paragraphs[0]
-
-      let label = ''
-      let href = ''
-      let subLinks = []
-      let hasData = true
-
-      if (link) {
-        label = link.label
-        href = link.href
-        if (nestedList) {
-          subLinks = Block.parseNestedLinks(nestedList, website)
-        }
-      } else {
-        label = text
-        hasData = false
-        if (nestedList) {
-          subLinks = Block.parseNestedLinks(nestedList, website)
-        }
-      }
-
-      parsed.push({
-        label,
-        route: website?.makeHref(href) || href,
-        child_items: subLinks,
-        hasData
-      })
-    }
-
-    return parsed
-  }
-}

package/src/core/input.js

@@ -1,15 +0,0 @@
-/**
- * Input
- *
- * Handles input/form data within blocks.
- */
-
-export default class Input {
-  constructor(inputData) {
-    this.data = inputData || {}
-  }
-
-  getData() {
-    return this.data
-  }
-}

package/src/core/page.js

@@ -1,75 +0,0 @@
-/**
- * Page
- *
- * Represents a single page with header, body sections, and footer.
- */
-
-import Block from './block.js'
-
-export default class Page {
-  constructor(pageData, id, pageHeader, pageFooter) {
-    this.id = id
-    this.route = pageData.route
-    this.title = pageData.title || ''
-    this.description = pageData.description || ''
-
-    this.pageBlocks = this.buildPageBlocks(
-      pageData.sections,
-      pageHeader?.sections,
-      pageFooter?.sections
-    )
-  }
-
-  /**
-   * Build the page block structure
-   */
-  buildPageBlocks(body, header, footer) {
-    const headerSection = header?.[0]
-    const footerSection = footer?.[0]
-    const bodySections = body || []
-
-    return {
-      header: headerSection ? new Block(headerSection, 'header') : null,
-      body: bodySections.map((section, index) => new Block(section, index)),
-      footer: footerSection ? new Block(footerSection, 'footer') : null,
-      leftPanel: null,
-      rightPanel: null
-    }
-  }
-
-  /**
-   * Get all blocks (header, body, footer) as flat array
-   * @returns {Block[]}
-   */
-  getPageBlocks() {
-    return [
-      this.pageBlocks.header,
-      ...this.pageBlocks.body,
-      this.pageBlocks.footer
-    ].filter(Boolean)
-  }
-
-  /**
-   * Get just body blocks
-   * @returns {Block[]}
-   */
-  getBodyBlocks() {
-    return this.pageBlocks.body
-  }
-
-  /**
-   * Get header block
-   * @returns {Block|null}
-   */
-  getHeader() {
-    return this.pageBlocks.header
-  }
-
-  /**
-   * Get footer block
-   * @returns {Block|null}
-   */
-  getFooter() {
-    return this.pageBlocks.footer
-  }
-}

package/src/core/uniweb.js

@@ -1,103 +0,0 @@
-/**
- * Uniweb Core Runtime
- *
- * The main runtime instance that manages the website, foundation components,
- * and provides utilities to components.
- */
-
-import Website from './website.js'
-
-export default class Uniweb {
-  constructor(configData) {
-    this.activeWebsite = new Website(configData)
-    this.childBlockRenderer = null // Function to render child blocks
-    this.routingComponents = {} // Link, SafeHtml, useNavigate, etc.
-    this.foundation = null // The loaded foundation module
-    this.foundationConfig = {} // Configuration from foundation
-    this.language = 'en'
-  }
-
-  /**
-   * Set the foundation module after loading
-   * @param {Object} foundation - The loaded ESM foundation module
-   */
-  setFoundation(foundation) {
-    this.foundation = foundation
-  }
-
-  /**
-   * Get a component from the foundation by name
-   * @param {string} name - Component name
-   * @returns {React.ComponentType|undefined}
-   */
-  getComponent(name) {
-    if (!this.foundation) {
-      console.warn('[Runtime] No foundation loaded')
-      return undefined
-    }
-
-    // Use foundation's getComponent interface
-    if (typeof this.foundation.getComponent === 'function') {
-      return this.foundation.getComponent(name)
-    }
-
-    // Fallback: direct component access
-    return this.foundation[name]
-  }
-
-  /**
-   * List available components from the foundation
-   * @returns {string[]}
-   */
-  listComponents() {
-    if (!this.foundation) return []
-
-    if (typeof this.foundation.listComponents === 'function') {
-      return this.foundation.listComponents()
-    }
-
-    return []
-  }
-
-  /**
-   * Get component schema
-   * @param {string} name - Component name
-   * @returns {Object|undefined}
-   */
-  getSchema(name) {
-    if (!this.foundation) return undefined
-
-    if (typeof this.foundation.getSchema === 'function') {
-      return this.foundation.getSchema(name)
-    }
-
-    return undefined
-  }
-
-  /**
-   * Set foundation configuration
-   * @param {Object} config
-   */
-  setFoundationConfig(config) {
-    this.foundationConfig = config
-  }
-
-  // Legacy compatibility - maps to new method names
-  getRemoteComponent(name) {
-    return this.getComponent(name)
-  }
-
-  setRemoteComponents(components) {
-    // Legacy: components was an object map
-    // Convert to foundation-like interface
-    this.foundation = {
-      getComponent: (name) => components[name],
-      listComponents: () => Object.keys(components),
-      components
-    }
-  }
-
-  setRemoteConfig(config) {
-    this.setFoundationConfig(config)
-  }
-}

package/src/core/website.js

@@ -1,157 +0,0 @@
-/**
- * Website
- *
- * Manages pages, themes, and localization for a website instance.
- */
-
-import Page from './page.js'
-
-export default class Website {
-  constructor(websiteData) {
-    const { pages = [], theme = {}, config = {} } = websiteData
-
-    // Extract special pages (header, footer) and regular pages
-    this.headerPage = pages.find((p) => p.route === '/@header')
-    this.footerPage = pages.find((p) => p.route === '/@footer')
-
-    this.pages = pages
-      .filter((page) => page.route !== '/@header' && page.route !== '/@footer')
-      .map(
-        (page, index) =>
-          new Page(page, index, this.headerPage, this.footerPage)
-      )
-
-    this.activePage =
-      this.pages.find((page) => page.route === '/' || page.route === '/index') ||
-      this.pages[0]
-
-    this.pageRoutes = this.pages.map((page) => page.route)
-    this.themeData = theme
-    this.config = config
-    this.activeLang = config.defaultLanguage || 'en'
-    this.langs = config.languages || [
-      { label: 'English', value: 'en' },
-      { label: 'français', value: 'fr' }
-    ]
-  }
-
-  /**
-   * Get page by route
-   * @param {string} route
-   * @returns {Page|undefined}
-   */
-  getPage(route) {
-    return this.pages.find((page) => page.route === route)
-  }
-
-  /**
-   * Set active page by route
-   * @param {string} route
-   */
-  setActivePage(route) {
-    const page = this.getPage(route)
-    if (page) {
-      this.activePage = page
-    }
-  }
-
-  /**
-   * Get remote layout component from foundation config
-   */
-  getRemoteLayout() {
-    return globalThis.uniweb?.foundationConfig?.Layout || null
-  }
-
-  /**
-   * Get remote props from foundation config
-   */
-  getRemoteProps() {
-    return globalThis.uniweb?.foundationConfig?.props || null
-  }
-
-  /**
-   * Get routing components (Link, useNavigate, etc.)
-   */
-  getRoutingComponents() {
-    return globalThis.uniweb?.routingComponents || {}
-  }
-
-  /**
-   * Make href (for link transformation)
-   * @param {string} href
-   * @returns {string}
-   */
-  makeHref(href) {
-    // Could add basename handling here
-    return href
-  }
-
-  /**
-   * Get available languages
-   */
-  getLanguages() {
-    return this.langs
-  }
-
-  /**
-   * Get current language
-   */
-  getLanguage() {
-    return this.activeLang
-  }
-
-  /**
-   * Localize a value
-   * @param {any} val - Value to localize (object with lang keys, or string)
-   * @param {string} defaultVal - Default value if not found
-   * @param {string} givenLang - Override language
-   * @param {boolean} fallbackDefaultLangVal - Fall back to default language
-   * @returns {string}
-   */
-  localize(val, defaultVal = '', givenLang = '', fallbackDefaultLangVal = false) {
-    const lang = givenLang || this.activeLang
-    const defaultLang = this.langs[0]?.value || 'en'
-
-    if (typeof val === 'object' && !Array.isArray(val)) {
-      return fallbackDefaultLangVal
-        ? val?.[lang] || val?.[defaultLang] || defaultVal
-        : val?.[lang] || defaultVal
-    }
-
-    if (typeof val === 'string') {
-      if (!val.startsWith('{') && !val.startsWith('"')) return val
-
-      try {
-        const obj = JSON.parse(val)
-        if (typeof obj === 'object') {
-          return fallbackDefaultLangVal
-            ? obj?.[lang] || obj?.[defaultLang] || defaultVal
-            : obj?.[lang] || defaultVal
-        }
-        return obj
-      } catch {
-        return val
-      }
-    }
-
-    return defaultVal
-  }
-
-  /**
-   * Get search data for all pages
-   */
-  getSearchData() {
-    return this.pages.map((page) => ({
-      id: page.id,
-      title: page.title,
-      href: page.route,
-      route: page.route,
-      description: page.description,
-      content: page
-        .getPageBlocks()
-        .map((b) => b.title)
-        .filter(Boolean)
-        .join('\n')
-    }))
-  }
-}