@uniweb/core 0.1.2

package/README.md

@@ -0,0 +1,154 @@
+# @uniweb/core
+
+Core classes for the Uniweb Component Web Platform.
+
+## Overview
+
+This package provides the foundational classes that power Uniweb sites. It's a pure JavaScript library with no React dependencies, designed to be shared between the runtime and foundations.
+
+## Installation
+
+```bash
+npm install @uniweb/core
+```
+
+## Usage
+
+```js
+import { createUniweb, getUniweb } from '@uniweb/core'
+
+// Create the singleton instance (typically done by @uniweb/runtime)
+const uniweb = createUniweb(siteConfig)
+
+// Access the singleton from anywhere
+const uniweb = getUniweb()
+
+// Work with the active website
+const website = uniweb.activeWebsite
+const page = website.getPage('/about')
+const language = website.getLanguage()
+```
+
+## API
+
+### Factory Functions
+
+| Function | Description |
+|----------|-------------|
+| `createUniweb(config)` | Create and register the global Uniweb instance |
+| `getUniweb()` | Get the current Uniweb instance |
+
+### Classes
+
+#### Uniweb
+
+The main runtime instance, available as `globalThis.uniweb`.
+
+```js
+uniweb.getComponent(name)     // Get component from foundation
+uniweb.listComponents()       // List available components
+uniweb.activeWebsite          // Current website instance
+uniweb.setFoundation(module)  // Set the foundation module
+```
+
+#### Website
+
+Manages pages, theme, and localization.
+
+```js
+website.getPage(route)        // Get page by route
+website.setActivePage(route)  // Navigate to page
+website.localize(value)       // Localize a multilingual value
+website.getLanguage()         // Get current language code
+website.getLanguages()        // Get available languages
+website.makeHref(href)        // Transform href for routing
+```
+
+#### Page
+
+Represents a page with its sections.
+
+```js
+page.route                    // Page route path
+page.title                    // Page title
+page.sections                 // Array of section blocks
+```
+
+#### Block
+
+Represents a section/component on a page.
+
+```js
+block.component               // Component name
+block.getBlockContent()       // Get parsed content
+block.getBlockProperties()    // Get configuration properties
+block.childBlockRenderer      // Renderer for child blocks
+```
+
+#### Input
+
+Handles form input fields with validation.
+
+```js
+input.value                   // Current value
+input.validate()              // Run validation
+input.errors                  // Validation errors
+```
+
+## Architecture
+
+```
+@uniweb/runtime (browser)
+    │
+    └── imports @uniweb/core
+            │
+            ├── createUniweb() - creates singleton
+            ├── Uniweb - main instance
+            ├── Website - page/locale management
+            ├── Page - page representation
+            ├── Block - section representation
+            └── Input - form handling
+
+@uniweb/kit (foundation components)
+    │
+    └── imports @uniweb/core
+            │
+            └── getUniweb() - access singleton
+```
+
+## For Foundation Creators
+
+Foundations typically don't import from `@uniweb/core` directly. Instead, use `@uniweb/kit` which provides React hooks and components that abstract the core:
+
+```js
+// Prefer this (kit)
+import { useWebsite } from '@uniweb/kit'
+const { localize, website } = useWebsite()
+
+// Instead of this (core)
+import { getUniweb } from '@uniweb/core'
+const website = getUniweb().activeWebsite
+```
+
+Mark `@uniweb/core` as external in your foundation's Vite config:
+
+```js
+// vite.config.js
+export default {
+  build: {
+    rollupOptions: {
+      external: ['react', 'react-dom', 'react-router-dom', '@uniweb/core']
+    }
+  }
+}
+```
+
+## Related Packages
+
+- [`@uniweb/runtime`](https://github.com/uniweb/runtime) - Browser runtime (creates the Uniweb instance)
+- [`@uniweb/kit`](https://github.com/uniweb/kit) - Component library for foundations
+- [`@uniweb/build`](https://github.com/uniweb/build) - Build tooling
+
+## License
+
+Apache 2.0

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@uniweb/core",
+  "version": "0.1.2",
+  "description": "Core classes for the Uniweb platform - Uniweb, Website, Page, Block",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "files": [
+    "src"
+  ],
+  "keywords": [
+    "uniweb",
+    "core"
+  ],
+  "author": "Proximify",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/uniweb/core.git"
+  },
+  "homepage": "https://github.com/uniweb/core#readme",
+  "bugs": {
+    "url": "https://github.com/uniweb/core/issues"
+  },
+  "engines": {
+    "node": ">=20.19"
+  },
+  "dependencies": {
+    "@uniweb/semantic-parser": "1.0.1"
+  }
+}

package/src/block.js

@@ -0,0 +1,311 @@
+/**
+ * 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/index.js

@@ -0,0 +1,37 @@
+/**
+ * @uniweb/core
+ *
+ * Core classes for the Uniweb platform.
+ * Pure JavaScript - no React or framework dependencies.
+ */
+
+import Uniweb from './uniweb.js'
+
+// Core classes
+export { Uniweb }
+export { default as Website } from './website.js'
+export { default as Page } from './page.js'
+export { default as Block } from './block.js'
+export { default as Input } from './input.js'
+
+/**
+ * The singleton Uniweb instance.
+ * Created by the runtime during initialization.
+ * Access via globalThis.uniweb or import { getUniweb } from '@uniweb/core'
+ */
+export function getUniweb() {
+  return globalThis.uniweb
+}
+
+/**
+ * Create and register the Uniweb singleton.
+ * Called by @uniweb/runtime during site initialization.
+ *
+ * @param {Object} configData - Website configuration (pages, theme, config)
+ * @returns {Uniweb} The created instance
+ */
+export function createUniweb(configData) {
+  const instance = new Uniweb(configData)
+  globalThis.uniweb = instance
+  return instance
+}

package/src/input.js

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

package/src/page.js

@@ -0,0 +1,75 @@
+/**
+ * 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/uniweb.js

@@ -0,0 +1,103 @@
+/**
+ * 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/website.js

@@ -0,0 +1,157 @@
+/**
+ * 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')
+    }))
+  }
+}