@uniweb/core 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/core",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Core classes for the Uniweb platform - Uniweb, Website, Page, Block",
   "type": "module",
   "exports": {

package/src/block.js

@@ -10,9 +10,14 @@ import { parseContent as parseSemanticContent } from '@uniweb/semantic-parser'
 export default class Block {
   constructor(blockData, id) {
     this.id = id
-    this.component = blockData.component || 'Section'
+    // 'type' matches frontmatter convention; 'component' supported for backwards compatibility
+    this.type = blockData.type || blockData.component || 'Section'
     this.Component = null
 
+    // Back-references (set by Page when creating blocks)
+    this.page = null
+    this.website = null
+
     // Content structure
     // The content can be:
     // 1. Raw ProseMirror content (from content collection)
@@ -28,7 +33,7 @@ export default class Block {
     // Block configuration
     const blockConfig = blockData.params || blockData.config || {}
     this.preset = blockData.preset
-    this.themeName = `context__${blockConfig.theme || 'light'}`
+    this.themeName = blockConfig.theme || 'light'
     this.standardOptions = blockConfig.standardOptions || {}
     this.properties = blockConfig.properties || blockConfig
 
@@ -40,10 +45,13 @@ export default class Block {
     // Input data
     this.input = blockData.input || null
 
-    // State management
+    // State management (dynamic, can change at runtime)
     this.startState = null
     this.state = null
     this.resetStateHook = null
+
+    // Context (static, defined per component type)
+    this.context = null
   }
 
   /**
@@ -160,18 +168,25 @@ export default class Block {
   initComponent() {
     if (this.Component) return this.Component
 
-    this.Component = globalThis.uniweb?.getComponent(this.component)
+    this.Component = globalThis.uniweb?.getComponent(this.type)
 
     if (!this.Component) {
-      console.warn(`[Block] Component not found: ${this.component}`)
+      console.warn(`[Block] Component not found: ${this.type}`)
       return null
     }
 
-    // Initialize state from component defaults
-    const defaults = this.Component.blockDefaults || { state: this.Component.blockState }
-    this.startState = defaults.state ? { ...defaults.state } : null
+    // Get component-level block configuration
+    // Supports: Component.block (preferred), Component.blockDefaults (legacy)
+    const blockConfig = this.Component.block || this.Component.blockDefaults || {}
+
+    // Initialize state (dynamic, can change at runtime)
+    const stateDefaults = blockConfig.state || this.Component.blockState
+    this.startState = stateDefaults ? { ...stateDefaults } : null
     this.initState()
 
+    // Initialize context (static, per component type)
+    this.context = blockConfig.context ? { ...blockConfig.context } : null
+
     return this.Component
   }
 
@@ -243,6 +258,59 @@ export default class Block {
     if (this.resetStateHook) this.resetStateHook()
   }
 
+  // ─────────────────────────────────────────────────────────────────
+  // Cross-Block Communication
+  // ─────────────────────────────────────────────────────────────────
+
+  /**
+   * Get this block's index within its page.
+   * Useful for finding neighboring blocks.
+   *
+   * @returns {number} The index, or -1 if not found
+   */
+  getIndex() {
+    if (!this.page) return -1
+    return this.page.getBlockIndex(this)
+  }
+
+  /**
+   * Get information about this block for cross-component communication.
+   * Other components (like NavBar) can use this to adapt their behavior.
+   *
+   * @returns {Object} Block info: { type, theme, state, context }
+   */
+  getBlockInfo() {
+    return {
+      type: this.type,
+      theme: this.themeName,
+      state: this.state,
+      context: this.context
+    }
+  }
+
+  /**
+   * Get information about the next block in the page.
+   * Commonly used by headers/navbars to adapt to the first content section.
+   *
+   * @returns {Object|null} Next block's info or null
+   */
+  getNextBlockInfo() {
+    const index = this.getIndex()
+    if (index < 0 || !this.page) return null
+    return this.page.getBlockInfo(index + 1)
+  }
+
+  /**
+   * Get information about the previous block in the page.
+   *
+   * @returns {Object|null} Previous block's info or null
+   */
+  getPrevBlockInfo() {
+    const index = this.getIndex()
+    if (index <= 0 || !this.page) return null
+    return this.page.getBlockInfo(index - 1)
+  }
+
   /**
    * React hook for block state management
    * @param {Function} useState - React useState hook

package/src/page.js

@@ -8,7 +8,7 @@
 import Block from './block.js'
 
 export default class Page {
-  constructor(pageData, id, pageHeader, pageFooter, pageLeft, pageRight) {
+  constructor(pageData, id, website, pageHeader, pageFooter, pageLeft, pageRight) {
     this.id = id
     this.route = pageData.route
     this.title = pageData.title || ''
@@ -48,9 +48,9 @@ export default class Page {
     // Child pages (for nested hierarchy) - populated by Website
     this.children = []
 
-    // Back-reference to website (set by Website constructor)
-    this.website = null
-    this.site = null // Alias
+    // Back-reference to website
+    this.website = website
+    this.site = website // Alias
 
     // Scroll position memory (for navigation restoration)
     this.scrollY = 0
@@ -99,18 +99,46 @@ export default class Page {
   buildPageBlocks(body, header, footer, left, right) {
     const buildBlocks = (sections, prefix) => {
       if (!sections || sections.length === 0) return null
-      return sections.map((section, index) => new Block(section, `${prefix}-${index}`))
+      return sections.map((section, index) => {
+        const block = new Block(section, `${prefix}-${index}`)
+        this.initBlockReferences(block)
+        return block
+      })
     }
 
+    const bodyBlocks = (body || []).map((section, index) => {
+      const block = new Block(section, index)
+      this.initBlockReferences(block)
+      return block
+    })
+
     return {
       header: buildBlocks(header, 'header'),
-      body: (body || []).map((section, index) => new Block(section, index)),
+      body: bodyBlocks,
       footer: buildBlocks(footer, 'footer'),
       left: buildBlocks(left, 'left'),
       right: buildBlocks(right, 'right')
     }
   }
 
+  /**
+   * Initialize block back-references to page and website.
+   * Also recursively sets references for child blocks.
+   *
+   * @param {Block} block - The block to initialize
+   */
+  initBlockReferences(block) {
+    block.page = this
+    block.website = this.website
+
+    // Recursively set references for child blocks
+    if (block.childBlocks?.length) {
+      for (const childBlock of block.childBlocks) {
+        this.initBlockReferences(childBlock)
+      }
+    }
+  }
+
   /**
    * Get all block groups (for Layout component)
    * @returns {Object} { header, body, footer, left, right }
@@ -119,6 +147,46 @@ export default class Page {
     return this.pageBlocks
   }
 
+  // ─────────────────────────────────────────────────────────────────
+  // Cross-Block Communication
+  // ─────────────────────────────────────────────────────────────────
+
+  /**
+   * Find a block's index within the page's block list.
+   * Searches across all layout areas (header, body, footer, left, right).
+   *
+   * @param {Block} block - The block to find
+   * @returns {number} The index in the flat list, or -1 if not found
+   */
+  getBlockIndex(block) {
+    const allBlocks = this.getPageBlocks()
+    return allBlocks.indexOf(block)
+  }
+
+  /**
+   * Get information about a block at a specific index.
+   * Used for cross-component communication (e.g., NavBar checking Hero's theme).
+   *
+   * @param {number} index - The block index
+   * @returns {Object|null} Block info { theme, component, state } or null
+   */
+  getBlockInfo(index) {
+    const allBlocks = this.getPageBlocks()
+    const block = allBlocks[index]
+    return block?.getBlockInfo() || null
+  }
+
+  /**
+   * Get the first body block's info.
+   * Common use case: NavBar checking if first section supports overlay.
+   *
+   * @returns {Object|null} First body block's info or null
+   */
+  getFirstBodyBlockInfo() {
+    const bodyBlocks = this.pageBlocks.body
+    return bodyBlocks?.[0]?.getBlockInfo() || null
+  }
+
   /**
    * Get all blocks (header, body, footer) as flat array
    * Respects page layout preferences (hasHeader, hasFooter, etc.)

package/src/website.js

@@ -46,14 +46,11 @@ export default class Website {
       .filter((page) => !specialRoutes.includes(page.route))
       .map(
         (page, index) =>
-          new Page(page, index, this.headerPage, this.footerPage, this.leftPage, this.rightPage)
+          new Page(page, index, this, this.headerPage, this.footerPage, this.leftPage, this.rightPage)
       )
 
-    // Set reference from pages back to website
-    for (const page of this.pages) {
-      page.website = this
-      page.site = this // Alias
-    }
+    // Build parent-child relationships based on route structure
+    this.buildPageHierarchy()
 
     this.activePage =
       this.pages.find((page) => page.route === '/' || page.route === '/index') ||
@@ -104,6 +101,53 @@ export default class Website {
     }))
   }
 
+  /**
+   * Build parent-child relationships between pages based on route structure
+   * E.g., /getting-started/installation is a child of /getting-started
+   * @private
+   */
+  buildPageHierarchy() {
+    // Sort pages by route depth (parents before children)
+    const sortedPages = [...this.pages].sort((a, b) => {
+      const depthA = (a.route.match(/\//g) || []).length
+      const depthB = (b.route.match(/\//g) || []).length
+      return depthA - depthB
+    })
+
+    // Build a map of route to page for quick lookup
+    const pageMap = new Map()
+    for (const page of sortedPages) {
+      pageMap.set(page.route, page)
+    }
+
+    // For each page, find its parent and add it as a child
+    for (const page of sortedPages) {
+      const route = page.route
+      if (route === '/' || route === '') continue
+
+      // Find parent route by removing the last segment
+      // /getting-started/installation -> /getting-started
+      const segments = route.split('/').filter(Boolean)
+      if (segments.length <= 1) continue // Root-level pages have no parent
+
+      // Build parent route
+      const parentRoute = '/' + segments.slice(0, -1).join('/')
+      const parent = pageMap.get(parentRoute)
+
+      if (parent) {
+        parent.children.push(page)
+        page.parent = parent
+      }
+    }
+
+    // Sort children by order
+    for (const page of this.pages) {
+      if (page.children.length > 0) {
+        page.children.sort((a, b) => (a.order || 0) - (b.order || 0))
+      }
+    }
+  }
+
   /**
    * Get page by route
    * @param {string} route
@@ -287,8 +331,60 @@ export default class Website {
     return defaultVal
   }
 
+  // ─────────────────────────────────────────────────────────────────
+  // Search API
+  // ─────────────────────────────────────────────────────────────────
+
+  /**
+   * Check if search is enabled for this site
+   * @returns {boolean}
+   */
+  isSearchEnabled() {
+    // Search is enabled by default unless explicitly disabled
+    return this.config?.search?.enabled !== false
+  }
+
+  /**
+   * Get search configuration
+   * @returns {Object} Search configuration
+   */
+  getSearchConfig() {
+    const config = this.config?.search || {}
+
+    return {
+      enabled: this.isSearchEnabled(),
+      indexUrl: this.getSearchIndexUrl(),
+      locale: this.getActiveLocale(),
+      include: {
+        pages: config.include?.pages !== false,
+        sections: config.include?.sections !== false,
+        headings: config.include?.headings !== false,
+        paragraphs: config.include?.paragraphs !== false,
+        links: config.include?.links !== false,
+        lists: config.include?.lists !== false
+      },
+      exclude: {
+        routes: config.exclude?.routes || [],
+        components: config.exclude?.components || []
+      }
+    }
+  }
+
+  /**
+   * Get the URL for the search index file
+   * @returns {string} URL to fetch the search index
+   */
+  getSearchIndexUrl() {
+    const locale = this.getActiveLocale()
+    const isDefault = locale === this.getDefaultLocale()
+
+    // Default locale uses root path, others use locale prefix
+    return isDefault ? '/search-index.json' : `/${locale}/search-index.json`
+  }
+
   /**
    * Get search data for all pages
+   * @deprecated Use getSearchConfig() and fetch the search index instead
    */
   getSearchData() {
     return this.pages.map((page) => ({
@@ -345,7 +441,7 @@ export default class Website {
     } = options
 
     // Filter pages based on navigation type and visibility
-    let filteredPages = this.pages.filter(page => {
+    const isPageVisible = (page) => {
       // Always exclude special pages (header/footer are already separated)
       if (page.route.startsWith('/@')) return false
 
@@ -360,7 +456,15 @@ export default class Website {
       if (customFilter && !customFilter(page)) return false
 
       return true
-    })
+    }
+
+    let filteredPages = this.pages.filter(isPageVisible)
+
+    // When nested, only include root-level pages at top level
+    // (children will be nested inside their parents)
+    if (nested) {
+      filteredPages = filteredPages.filter(page => !page.parent)
+    }
 
     // Apply custom sort or default to order
     if (customSort) {
@@ -378,7 +482,7 @@ export default class Website {
       order: page.order,
       hasContent: page.getBodyBlocks().length > 0,
       children: nested && page.hasChildren()
-        ? page.children.map(buildPageInfo)
+        ? page.children.filter(isPageVisible).map(buildPageInfo)
         : []
     })