coralite-plugin-aggregation 0.6.0 → 0.7.1

package/lib/index.js

@@ -1,366 +1,289 @@
+import { createPlugin } from 'coralite'
 import path from 'node:path'
-import { access } from 'node:fs/promises'
-import { getHtmlFiles, createPlugin } from 'coralite'
-import { pathToFileURL } from 'node:url'
 
 /**
- * @import {CoraliteAnyNode, CoraliteCollectionItem} from 'coralite/types'
- * @import {CoraliteAggregate} from '../types/index.js'
+ * Aggregates content based on configuration
+ * @param {import('../types/index.js').AggregationOptions} options
+ * @param {Object} contextInstance
+ * @returns {Promise<any[]>}
  */
-
-export default createPlugin({
-  name: 'aggregation',
-  /**
-   * Aggregates HTML content from specified paths into a single collection of components.
-   *
-   * @param {CoraliteAggregate} options - Configuration object defining the aggregation behavior
-   *
-   * @returns {Promise<CoraliteAnyNode[]>} Array of processed content nodes from aggregated documents
-   * @throws {Error} If pages directory path is undefined or aggregate path doesn't exist
-   *
-   */
-  async method (options, context) {
-    let templateId
-
-    // Determine template component ID from configuration
-    if (typeof options.template === 'string') {
-      templateId = options.template
-    } else if (typeof options.template === 'object') {
-      templateId = options.template.item
-    }
-
-    if (!templateId) {
-      /** @TODO Refer to documentation */
-      throw new Error('Aggregate template was undefined')
+async function aggregationMethod (options, contextInstance) {
+  const {
+    path: paths = [],
+    template,
+    pagination,
+    filter,
+    sort,
+    limit,
+    offset = 0,
+    recursive = false,
+    tokens
+  } = options
+
+  const contextValues = contextInstance.values
+  const pagesRoot = this.options.pages
+
+  // 1. Collect pages
+  let allPages = []
+  const uniquePaths = new Set()
+
+  for (const relativePath of paths) {
+    const targetPath = path.join(pagesRoot, relativePath)
+
+    // Check direct path match in listByPath (non-recursive)
+    if (!recursive) {
+      const pagesInDir = this.pages.getListByPath(targetPath)
+      if (pagesInDir) {
+        for (const page of pagesInDir) {
+          if (!uniquePaths.has(page.path.pathname)) {
+            uniquePaths.add(page.path.pathname)
+            allPages.push(page)
+          }
+        }
+      }
+    } else {
+      // Recursive search
+      for (const page of this.pages.list) {
+        const dirname = page.path.dirname
+        // Check if dirname is targetPath or a subdirectory of targetPath
+        if (dirname === targetPath || dirname.startsWith(targetPath + path.sep)) {
+          if (!uniquePaths.has(page.path.pathname)) {
+            uniquePaths.add(page.path.pathname)
+            allPages.push(page)
+          }
+        }
+      }
     }
+  }
+
+  // 2. Filter
+  if (typeof filter === 'function') {
+    allPages = allPages.filter(page => {
+      // Access values from result property
+      const values = page.result && page.result.values ? page.result.values : page.values
+      return filter(values)
+    })
+  }
+
+  // 3. Sort
+  if (typeof sort === 'function') {
+    allPages.sort((a, b) => {
+      const valA = a.result && a.result.values ? a.result.values : a.values
+      const valB = b.result && b.result.values ? b.result.values : b.values
+      return sort(valA, valB)
+    })
+  }
 
-    /** @type {CoraliteCollectionItem[]} */
-    let pages = []
+  // 4. Pagination
+  let startIndex = offset
+  let endIndex = allPages.length
 
-    for (let i = 0; i < options.path.length; i++) {
-      const optionPath = options.path[i];
-      const dirname = path.join(context.path.pages, optionPath)
+  let currentPage = 1
+  let totalPages = 1
 
-      try {
-        await access(dirname)
-      } catch (error) {
-        throw new Error('Aggregate path does not exist: "' + dirname + '"')
-      }
+  // Ensure renderContext is available
+  const currentRenderContext = contextInstance.renderContext
+  const buildId = currentRenderContext && currentRenderContext.buildId
 
-      const cachePages = this.pages.getListByPath(dirname)
+  if (limit) {
+    if (pagination) {
+      const segment = pagination.segment || 'page'
+      const urlPathname = contextValues.$urlPathname || ''
 
-      if (!cachePages || !cachePages.length) {
-        // Retrieve HTML pages from specified path
-        const collection = await getHtmlFiles({
-          type: 'page',
-          path: dirname
-        })
+      const escapedSegment = segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 
-        if (!collection.list.length) {
-          throw new Error('Aggregation found no documents in "' + dirname + '"')
-        }
+      // Try to match segment in URL: /.../segment/Number
+      const segmentRegex = new RegExp(`/${escapedSegment}/(\\d+)`)
+      const match = urlPathname.match(segmentRegex)
 
-        pages = pages.concat(collection.list)
-      } else {
-        pages = pages.concat(cachePages)
+      if (match) {
+        currentPage = parseInt(match[1], 10)
       }
-    }
-
-    let result = []
-    let startIndex = 0
-    let endIndex = pages.length
-    let paginationOffset = context.values.paginationOffset
 
-    // sort results based on custom sort function
-    if (typeof options.sort === 'function') {
-      pages.sort((a, b) => {
-        const metaA = a.result.values
-        const metaB = b.result.values
-
-        return options.sort(metaA, metaB)
-      })
-    }
+      startIndex = offset + (currentPage - 1) * limit
+      endIndex = startIndex + limit
+
+      totalPages = Math.ceil(allPages.length / limit)
+
+      // Automatically generate subsequent pagination pages if we are on the "root" page
+      // e.g., if we are on /blog/index.html (page 1), queue up /blog/page/2, /blog/page/3...
+      if (!match && currentPage === 1 && totalPages > 1 && buildId) {
+        const currentDocument = contextInstance.document
+        const currentPathname = currentDocument.path.pathname
+        const currentFilename = currentDocument.path.filename
+        const currentDirname = currentDocument.path.dirname
+
+        // Determine the output path structure based on rules
+        let targetDir = currentDirname
+        let urlPrefixBase = ''
+
+        // Rules:
+        // /index.html -> /page/1.html (relative to currentDirname)
+        // /blog.html -> /blog/page/1.html (creates subdirectory)
+        // /blog/index.html -> /blog/page/1.html (relative to currentDirname)
+        // /blog/today.html -> /blog/today/page/1.html (creates subdirectory)
+
+        if (currentFilename === 'index.html') {
+          // Standard case: keep in same directory
+          targetDir = currentDirname
+          // Prefix for URL generation in child
+          urlPrefixBase = path.dirname(urlPathname) // e.g. /blog/
+        } else {
+          // Named file: create subdirectory with same name (minus extension)
+          const basename = path.basename(currentFilename, path.extname(currentFilename))
+          targetDir = path.join(currentDirname, basename)
 
-    if (typeof options.filter === 'function') {
-      const filteredPages = []
-
-      for (let i = 0; i < pages.length; i++) {
-        const page = pages[i]
-        const metadata = page.result.values
-        let keepItem = false
-
-        // process metadata and populate token values for rendering
-        for (const key in metadata) {
-          if (Object.prototype.hasOwnProperty.call(metadata, key)) {
-            const data = metadata[key]
-
-            if (Array.isArray(data)) {
-              for (let i = 0; i < data.length; i++) {
-
-                if (!keepItem) {
-                  keepItem = options.filter({ name: key, content: data[i] })
-                }
-              }
-            } else {
-              // handle single metadata item
-              if (!keepItem) {
-                keepItem = options.filter({
-                  name: key,
-                  content: data
-                })
-              }
-            }
-          }
+          // e.g. /blog.html -> /blog/
+          urlPrefixBase = urlPathname.replace(path.extname(currentFilename), '')
         }
 
-        if (keepItem) {
-          filteredPages.push(page)
+        // Ensure trailing slash for URL prefix
+        if (!urlPrefixBase.endsWith('/')) urlPrefixBase += '/'
+        // path.dirname returns / for /index.html, but /blog for /blog/index.html.
+        // If /blog/index.html, urlPathname is /blog/index.html. dirname is /blog.
+
+        if (currentFilename === 'index.html') {
+          // Correct logic for index.html url prefix
+          // If /index.html, urlPathname /index.html. dirname /. prefix /.
+          // If /blog/index.html, urlPathname /blog/index.html. dirname /blog. prefix /blog/.
+          urlPrefixBase = path.dirname(urlPathname)
+          if (!urlPrefixBase.endsWith('/')) urlPrefixBase += '/'
         }
-      }
 
-      pages = filteredPages
-      endIndex = pages.length
-    }
-
-    // apply page offset
-    if (Object.prototype.hasOwnProperty.call(options, 'offset') || paginationOffset != null) {
-      let offset = paginationOffset || options.offset
-
-      if (!Array.isArray(offset)) {
-        if (typeof offset === 'string') {
-          offset = parseInt(offset)
-        }
+        // Retrieve the original item to get content
+        const currentItem = this.pages.getItem(currentDocument.path.pathname)
+
+        for (let i = 2; i <= totalPages; i++) {
+          const newPathname = path.join(targetDir, segment, `${i}.html`)
+
+          const virtualItem = {
+            content: currentItem ? currentItem.content : '', // Use original content
+            path: {
+              pathname: newPathname,
+              dirname: path.dirname(newPathname),
+              filename: path.basename(newPathname)
+            },
+            values: {
+              // Pass metadata to help resolve paths in children
+              meta_pagination_base_url: urlPathname,
+              // Calculate prefix once and pass it down
+              meta_pagination_url_prefix: urlPrefixBase
+            },
+            type: 'page'
+          }
 
-        if (offset > endIndex) {
-          startIndex = endIndex
-        } else {
-          startIndex = offset
+          // Add to queue
+          await this.addRenderQueue(virtualItem, buildId)
         }
       }
+    } else {
+      // Simple limit/offset without pagination logic
+      endIndex = Math.min(startIndex + limit, allPages.length)
     }
-
-    // apply page limit
-    let limit
-    if (options.limit) {
-      limit = options.limit
-
-      if (typeof limit === 'string') {
-        limit = parseInt(limit)
-      }
-
-      const limitOffset = limit + startIndex
-
-      if (limitOffset < endIndex) {
-        endIndex = limitOffset
+  }
+
+  const paginatedPages = allPages.slice(startIndex, endIndex)
+
+  // 5. Render Items
+  const resultNodes = []
+
+  for (const page of paginatedPages) {
+    const pageValues = page.result && page.result.values ? page.result.values : page.values
+    let itemValues = { ...pageValues }
+
+    // Apply token transformations
+    if (tokens && typeof tokens === 'object') {
+      for (const key in tokens) {
+        if (Object.prototype.hasOwnProperty.call(tokens, key)) {
+          const transform = tokens[key]
+          if (typeof transform === 'string') {
+            itemValues[key] = pageValues[transform]
+          } else if (typeof transform === 'function') {
+            itemValues[key] = transform(pageValues)
+          }
+        }
       }
     }
 
-    // Filter out index.html and current page from pages array
-    pages = pages.filter(p => {
-      // Always exclude index.html from pagination
-      if (p.path.filename === 'index.html') return false
-      
-      // Exclude current page if it matches
-      if (p.path.filename === context.document.path.filename) return false
-      
-      return true
-    })
-    
-    // Update endIndex after filtering
-    endIndex = Math.min(endIndex, pages.length)
-    
-    // Render content
-    for (let i = startIndex; i < endIndex; i++) {
-      let page = pages[i]
-
-      // render component with current values and add to results
+    // Render the item template
+    if (template) {
       const component = await this.createComponent({
-        id: templateId,
-        values: { ...context.values, ...page.result.values },
-        document: context.document,
-        contextId: context.id + i + templateId,
-        index: i
+        id: template,
+        values: itemValues,
+        document: contextInstance.document,
+        renderContext: currentRenderContext
       })
 
-      if (typeof component === 'object') {
-        // concat rendered components
-        result = result.concat(component.children)
+      if (component && component.children) {
+        resultNodes.push(...component.children)
       }
     }
+  }
 
-    // process pagination
-    if (options.pagination && limit) {
-      const pagination = options.pagination
-      const paginationSegment = context.values.paginationSegment || pagination.segment || 'page'
-      
-      // Calculate pagination length based on the filtered pages array
-      // Each page shows 'limit' items, so total pages = ceil(filteredPagesCount / limit)
-      const filteredPagesCount = pages.length
-      const paginationLength = Math.ceil(filteredPagesCount / limit)
-      
-      let processed = context.values.paginationProcessed
-
-      if (!processed && paginationLength > 1) {
-        const documentPath = context.document.path
-        
-        // remove file extension
-        let name = context.document.path.filename.replace(path.extname(context.document.path.filename), '')
-
-        if (name === 'index') {
-          name = ''
-        }
+  // 6. Render Pagination Controls
+  if (pagination) {
+    const segment = pagination.segment || 'page'
+    const escapedSegment = segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 
-        // Base directory for pagination pages
-        let baseDirname = documentPath.dirname
-        if (name) {
-          baseDirname = path.join(baseDirname, name)
-        }
-        
-        const paginationDirname = path.join(baseDirname, paginationSegment.toString())
-        
-        // Index page path - always the base index.html
-        const indexPathname = context.values.paginationIndexPathname || documentPath.pathname
-        // For URL calculation, we need to find the index page in the same directory structure
-        // If we're on /blog/page/2.html, the index is at /blog/index.html
-        let indexURLPathname = context.values.paginationIndexURLPathname
-        let indexURLDirname = context.values.paginationIndexURLDirname
-        
-        if (!indexURLDirname || !indexURLPathname) {
-          if (name) {
-            // Non-index page: index is in parent directory
-            const parentDir = path.dirname(documentPath.dirname)
-            const indexFile = path.join(parentDir, context.document.path.filename)
-            indexURLPathname = pathToFileURL(path.join('/', path.relative(this.options.path.pages, indexFile))).pathname
-            indexURLDirname = pathToFileURL(path.dirname(indexURLPathname)).pathname
-          } else {
-            // Index page
-            indexURLPathname = pathToFileURL(path.join('/', path.relative(this.options.path.pages, indexPathname))).pathname
-            indexURLDirname = pathToFileURL(path.dirname(indexURLPathname)).pathname
-          }
-        }
-        
-        const indexPage = this.pages.getItem(documentPath.pathname)
-        const maxVisiblePages = (pagination.maxVisible || paginationLength).toString()
-
-        // Generate pagination pages (page 2, 3, 4, etc.)
-        if (context.values.paginationFileDirname == null) {
-          for (let i = 1; i < paginationLength; i++) {
-            const currentPageIndex = i + 1
-            const filename = currentPageIndex + '.html'
-            const pathname = path.join(paginationDirname, filename)
-            const contextId = pathname + context.id.substring(documentPath.pathname.length)
-            
-            // Calculate offset for this page
-            const pageOffset = i * limit
-            
-            // URL for this pagination page
-            const urlPathname = pathToFileURL(path.join('/', path.relative(this.options.path.pages, pathname))).pathname
-            const urlDirname = pathToFileURL(path.dirname(urlPathname)).pathname
-
-            // Store context values for pagination page
-            // For pagination pages, use nested URL structure
-            const nestedURLPathname = pathToFileURL(path.join('/', path.relative(this.options.path.pages, pathname))).pathname
-            // For pagination pages, the URL dirname should be the full path without .html
-            // e.g., /blog/page/2.html -> /blog/page/2
-            const nestedURLDirname = nestedURLPathname.replace(/\.html$/, '')
-            
-            this.values[contextId] = {
-              ...context.values,
-              paginationIndexPathname: context.values.paginationIndexPathname,
-              paginationIndexURLPathname: context.values.paginationIndexURLPathname,
-              paginationIndexURLDirname: context.values.paginationIndexURLDirname,
-              paginationSegment: paginationSegment,
-              paginationMaxVisible: maxVisiblePages,
-              paginationProcessed: 'true',
-              paginationOffset: pageOffset.toString(),
-              paginationFilePathname: pathname,
-              paginationFileDirname: paginationDirname,
-              paginationURLPathname: nestedURLPathname,
-              paginationURLDirname: nestedURLDirname,
-              paginationLength: paginationLength.toString(),
-              paginationCurrent: currentPageIndex.toString(),
-            }
-
-            // Add pagination page to render queue
-            await this.addRenderQueue({
-              values: {
-                paginationIndexPathname: indexPathname,
-                paginationIndexURLPathname: indexURLPathname,
-                paginationIndexURLDirname: indexURLDirname,
-                paginationFileDirname: documentPath.dirname,
-              },
-              path: {
-                dirname: paginationDirname,
-                pathname,
-                filename
-              },
-              content: indexPage.content
-            })
-          }
-        }
+    const paginationTemplateId = pagination.template || 'coralite-pagination'
 
-        // Store pagination values for current page
-        // For non-index pages, use nested URL structure
-        let currentPaginationURLDirname
-        let currentPaginationURLPathname
-        
-        if (name) {
-          // Non-index page: use nested structure
-          // e.g., /blog/page/2 for page 2
-          currentPaginationURLPathname = indexURLPathname
-          // Calculate the full nested path
-          // For page 2: /blog/page/2
-          const relativePath = path.relative(this.options.path.pages, documentPath.dirname)
-          currentPaginationURLDirname = pathToFileURL(path.join('/', relativePath, name)).pathname
-        } else {
-          // Index page: use flat structure
-          currentPaginationURLPathname = indexURLPathname
-          currentPaginationURLDirname = indexURLDirname
-        }
-        context.values = { 
-          ...context.values,
-          paginationIndexPathname: indexPathname,
-          paginationIndexURLPathname: indexURLPathname,
-          paginationIndexURLDirname: indexURLDirname,
-          paginationSegment: paginationSegment,
-          paginationMaxVisible: maxVisiblePages,
-          paginationProcessed: 'true',
-          paginationOffset: limit.toString(),
-          paginationFilePathname: indexPathname,
-          paginationFileDirname: baseDirname,
-          paginationURLPathname: currentPaginationURLPathname,
-          paginationURLDirname: currentPaginationURLDirname,
-          paginationLength: paginationLength.toString(),
-          paginationCurrent: '1'
-        }
-      }
+    // Construct baseUrl and urlPrefix for template
+    const urlPathname = contextValues.$urlPathname
+    let baseUrl = urlPathname
+    let urlPrefix = ''
 
-      // Handle pagination pages (non-index pages)
-      const contextId = context.id
-      let values = this.values[contextId]
+    if (contextValues.meta_pagination_base_url) {
+      baseUrl = contextValues.meta_pagination_base_url
+    }
 
-      if (!values || !processed) {
-        values = context.values
-        this.values[contextId] = values
-      }
-      
-      const paginationTemplateId = pagination.template || 'coralite-pagination'
-
-      if (typeof paginationTemplateId === 'string') {
-        const component = await this.createComponent({
-          id: paginationTemplateId,
-          values,
-          document: context.document,
-          contextId: contextId + paginationTemplateId
-        })
-
-        if (typeof component === 'object') {
-          result = result.concat(component.children)
-        }
+    if (contextValues.meta_pagination_url_prefix) {
+      urlPrefix = contextValues.meta_pagination_url_prefix
+    } else {
+      // Page 1 logic calculation if not passed
+      if (baseUrl.endsWith('/index.html') || baseUrl.endsWith('/')) {
+        urlPrefix = path.dirname(baseUrl)
+      } else {
+        // Named file
+        const basename = path.basename(baseUrl, '.html')
+        urlPrefix = path.join(path.dirname(baseUrl), basename)
       }
     }
 
-    return result
-  },
-  templates: [path.join(import.meta.dirname, 'templates/coralite-pagination.html')]
+    // Normalize urlPrefix to ensure trailing slash
+    if (!urlPrefix.endsWith('/')) urlPrefix += '/'
+
+    const paginationValues = {
+      'current-page': String(currentPage),
+      'total-pages': String(totalPages),
+      'base-url': baseUrl,
+      'url-prefix': urlPrefix,
+      segment: pagination.segment || 'page',
+      'max-visible': String(pagination.maxVisible || 5),
+      'aria-label': pagination.ariaLabel || 'Pagination',
+      ellipsis: pagination.ellipsis || '...'
+    }
+
+    const component = await this.createComponent({
+      id: paginationTemplateId,
+      values: paginationValues,
+      document: contextInstance.document,
+      renderContext: currentRenderContext
+    })
+
+    if (component && component.children) {
+      resultNodes.push(...component.children)
+    }
+  }
+
+  return resultNodes
+}
+
+export const aggregation = createPlugin({
+  name: 'aggregation',
+  method: aggregationMethod,
+  templates: [
+    path.join(import.meta.dirname, 'templates/coralite-pagination.html')
+  ]
 })
+
+export default aggregation