@uniweb/core 0.1.10 → 0.1.12

package/README.md

@@ -126,7 +126,6 @@ page.label                    // Short navigation label (or null)
 page.order                    // Sort order
 page.children                 // Child pages (for nested hierarchy)
 page.website                  // Back-reference to parent Website
-page.site                     // Alias for page.website
 
 // Navigation visibility
 page.hidden                   // Hidden from all navigation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/core",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Core classes for the Uniweb platform - Uniweb, Website, Page, Block",
   "type": "module",
   "exports": {
@@ -27,6 +27,6 @@
     "node": ">=20.19"
   },
   "dependencies": {
-    "@uniweb/semantic-parser": "1.0.7"
+    "@uniweb/semantic-parser": "1.0.9"
   }
 }

package/src/block.js

@@ -26,9 +26,9 @@ export default class Block {
     this.rawContent = blockData.content || {}
     this.parsedContent = this.parseContent(blockData.content)
 
-    const { main, items } = this.parsedContent
-    this.main = main
-    this.items = items
+    // Flat content structure - no more nested main/items
+    // parsedContent now has: title, pretitle, paragraphs, links, imgs, items, etc.
+    this.items = this.parsedContent.items || []
 
     // Block configuration
     const blockConfig = blockData.params || blockData.config || {}
@@ -81,11 +81,10 @@ export default class Block {
     // 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)) {
+      // Mark as PoC format so runtime can detect and pass through
       return {
-        main: { header: {}, body: {} },
-        items: [],
-        // Store raw content for direct access
-        raw: content
+        _isPoc: true,
+        _pocContent: content
       }
     }
 
@@ -99,24 +98,15 @@ export default class Block {
   /**
    * Extract structured content from ProseMirror document
    * Uses @uniweb/semantic-parser for intelligent content extraction
+   * Returns flat content structure
    */
   extractFromProseMirror(doc) {
     try {
-      // Parse with semantic-parser
-      const { groups, sequence, byType } = parseSemanticContent(doc)
+      // Parse with semantic-parser - returns flat structure
+      const parsed = 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
-      }
+      // Parsed content is now flat: { title, pretitle, paragraphs, links, items, sequence, ... }
+      return parsed
     } catch (err) {
       console.warn('[Block] Semantic parser error, using fallback:', err.message)
       return this.extractFromProseMirrorFallback(doc)
@@ -125,29 +115,39 @@ export default class Block {
 
   /**
    * Fallback extraction when semantic-parser fails
+   * Returns flat content structure matching new parser output
    */
   extractFromProseMirrorFallback(doc) {
-    const main = { header: {}, body: {} }
-    const items = []
+    const content = {
+      title: '',
+      pretitle: '',
+      subtitle: '',
+      paragraphs: [],
+      links: [],
+      imgs: [],
+      lists: [],
+      icons: [],
+      items: [],
+      sequence: []
+    }
 
-    if (!doc.content) return { main, items }
+    if (!doc.content) return content
 
     for (const node of doc.content) {
       if (node.type === 'heading') {
         const text = this.extractText(node)
         if (node.attrs?.level === 1) {
-          main.header.title = text
+          content.title = text
         } else if (node.attrs?.level === 2) {
-          main.header.subtitle = text
+          content.subtitle = text
         }
       } else if (node.type === 'paragraph') {
         const text = this.extractText(node)
-        if (!main.body.paragraphs) main.body.paragraphs = []
-        main.body.paragraphs.push(text)
+        content.paragraphs.push(text)
       }
     }
 
-    return { main, items }
+    return content
   }
 
   /**
@@ -175,43 +175,43 @@ export default class Block {
       return null
     }
 
-    // Get component-level block configuration
-    // Supports: Component.block (preferred), Component.blockDefaults (legacy)
-    const blockConfig = this.Component.block || this.Component.blockDefaults || {}
+    // Get runtime metadata for this component (from meta.js, extracted at build time)
+    const meta = globalThis.uniweb?.getComponentMeta(this.type) || {}
 
     // Initialize state (dynamic, can change at runtime)
-    const stateDefaults = blockConfig.state || this.Component.blockState
+    // Source: meta.js initialState field
+    const stateDefaults = meta.initialState
     this.startState = stateDefaults ? { ...stateDefaults } : null
     this.initState()
 
     // Initialize context (static, per component type)
-    this.context = blockConfig.context ? { ...blockConfig.context } : null
+    // Source: meta.js context field
+    this.context = meta.context ? { ...meta.context } : null
 
     return this.Component
   }
 
   /**
    * Get structured block content for components
+   * Returns flat content structure
    */
   getBlockContent() {
-    const mainHeader = this.main?.header || {}
-    const mainBody = this.main?.body || {}
-    const banner = this.main?.banner || null
+    const c = this.parsedContent || {}
 
     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 || []
+      pretitle: c.pretitle || '',
+      title: c.title || '',
+      subtitle: c.subtitle || '',
+      description: c.subtitle2 || '',
+      paragraphs: c.paragraphs || [],
+      images: c.imgs || [],
+      links: c.links || [],
+      icons: c.icons || [],
+      properties: c.propertyBlocks?.[0] || c.properties || {},
+      videos: c.videos || [],
+      lists: c.lists || [],
+      buttons: c.buttons || [],
+      items: c.items || []
     }
   }
 
@@ -236,14 +236,15 @@ export default class Block {
    */
   getBlockLinks(options = {}) {
     const website = globalThis.uniweb?.activeWebsite
+    const c = this.parsedContent || {}
 
     if (options.nested) {
-      const lists = this.main?.body?.lists || []
+      const lists = c.lists || []
       const links = lists[0]
       return Block.parseNestedLinks(links, website)
     }
 
-    const links = this.main?.body?.links || []
+    const links = c.links || []
     return links.map((link) => ({
       route: website?.makeHref(link.href) || link.href,
       label: link.label

package/src/page.js

@@ -51,7 +51,6 @@ export default class Page {
 
     // Back-reference to website
     this.website = website
-    this.site = website // Alias
 
     // Scroll position memory (for navigation restoration)
     this.scrollY = 0
@@ -385,4 +384,80 @@ export default class Page {
   hasChildren() {
     return this.children.length > 0
   }
+
+  /**
+   * Check if page has body content (sections)
+   * @returns {boolean}
+   */
+  hasContent() {
+    return this.pageBlocks.body.length > 0
+  }
+
+  // ─────────────────────────────────────────────────────────────────
+  // Active Route Detection
+  // ─────────────────────────────────────────────────────────────────
+
+  /**
+   * Get the first navigable route for this page.
+   * If page has no content, recursively finds first child with content.
+   * Useful for category pages that are just navigation containers.
+   *
+   * @returns {string} The route to navigate to
+   *
+   * @example
+   * // For a "Docs" category page with no content but children:
+   * // page.route = '/docs'
+   * // page.hasContent() = false
+   * // First child with content: '/docs/getting-started'
+   * page.getNavigableRoute() // Returns '/docs/getting-started'
+   */
+  getNavigableRoute() {
+    if (this.hasContent()) return this.route
+    for (const child of this.children || []) {
+      const route = child.getNavigableRoute()
+      if (route) return route
+    }
+    return this.route // Fallback to own route
+  }
+
+  /**
+   * Get route without leading/trailing slashes.
+   * Useful for route comparisons.
+   *
+   * @returns {string} Normalized route (e.g., 'docs/getting-started')
+   */
+  getNormalizedRoute() {
+    return (this.route || '').replace(/^\//, '').replace(/\/$/, '')
+  }
+
+  /**
+   * Check if this page matches the given route exactly.
+   *
+   * @param {string} route - Normalized route (no leading/trailing slashes)
+   * @returns {boolean} True if this page's route matches
+   */
+  isActiveFor(route) {
+    return this.getNormalizedRoute() === route
+  }
+
+  /**
+   * Check if this page or any descendant matches the given route.
+   * Useful for highlighting parent nav items when a child page is active.
+   *
+   * @param {string} route - Normalized route (no leading/trailing slashes)
+   * @returns {boolean} True if this page or a descendant is active
+   *
+   * @example
+   * // Page route: '/docs'
+   * // Current route: 'docs/getting-started/installation'
+   * page.isActiveOrAncestor('docs/getting-started/installation') // true
+   */
+  isActiveOrAncestor(route) {
+    const pageRoute = this.getNormalizedRoute()
+    if (pageRoute === route) return true
+    // Check if route starts with this page's route followed by /
+    // Handle empty pageRoute (root) specially
+    if (pageRoute === '') return true // Root is ancestor of all
+    return route.startsWith(pageRoute + '/')
+  }
 }

package/src/uniweb.js

@@ -14,7 +14,8 @@ export default class Uniweb {
     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.foundationConfig = {} // Configuration from foundation (capabilities)
+    this.meta = {} // Per-component runtime metadata (from meta.js)
     this.language = 'en'
 
     // Initialize analytics (disabled by default, configure via site config)
@@ -27,6 +28,29 @@ export default class Uniweb {
    */
   setFoundation(foundation) {
     this.foundation = foundation
+
+    // Store per-component metadata if present
+    if (foundation.meta) {
+      this.meta = foundation.meta
+    }
+  }
+
+  /**
+   * Get runtime metadata for a component
+   * @param {string} componentName
+   * @returns {Object|null} Meta with defaults, context, initialState, background, data
+   */
+  getComponentMeta(componentName) {
+    return this.meta[componentName] || null
+  }
+
+  /**
+   * Get default param values for a component
+   * @param {string} componentName
+   * @returns {Object} Default values (empty object if none)
+   */
+  getComponentDefaults(componentName) {
+    return this.meta[componentName]?.defaults || {}
   }
 
   /**

package/src/website.js

@@ -489,11 +489,12 @@ export default class Website {
     const buildPageInfo = (page) => ({
       id: page.id,
       route: page.getNavRoute(), // Use canonical nav route (e.g., '/' for index pages)
+      navigableRoute: page.getNavigableRoute(), // First route with content (for links)
       title: page.title,
       label: page.getLabel(),
       description: page.description,
       order: page.order,
-      hasContent: page.getBodyBlocks().length > 0,
+      hasContent: page.hasContent(),
       children: nested && page.hasChildren()
         ? page.children.filter(isPageVisible).map(buildPageInfo)
         : []
@@ -528,4 +529,35 @@ export default class Website {
   getAllPages(includeHidden = false) {
     return this.getPageHierarchy({ nested: false, includeHidden })
   }
+
+  // ─────────────────────────────────────────────────────────────────
+  // Active Route API (for navigation components)
+  // ─────────────────────────────────────────────────────────────────
+
+  /**
+   * Get the current active route, normalized (no leading/trailing slashes).
+   * Works in both SSR (from activePage) and client (from activePage).
+   *
+   * @returns {string} Normalized route (e.g., 'docs/getting-started')
+   *
+   * @example
+   * website.getActiveRoute() // 'docs/getting-started'
+   */
+  getActiveRoute() {
+    return this.activePage?.getNormalizedRoute() || ''
+  }
+
+  /**
+   * Get the first segment of the active route.
+   * Useful for root-level navigation highlighting.
+   *
+   * @returns {string} First segment (e.g., 'docs' for 'docs/getting-started')
+   *
+   * @example
+   * // Active route: 'docs/getting-started/installation'
+   * website.getActiveRootSegment() // 'docs'
+   */
+  getActiveRootSegment() {
+    return this.getActiveRoute().split('/')[0]
+  }
 }