coralite-plugin-aggregation 0.8.0 → 0.10.0

package/lib/components/coralite-pagination.html

@@ -0,0 +1,99 @@
+<template id="coralite-pagination">
+  <nav aria-label="{{ ariaLabel }}">
+    <ul class="pagination">
+      {{ paginationLinks }}
+    </ul>
+  </nav>
+</template>
+
+<script type="module">
+  import { defineComponent } from 'coralite/plugins'
+
+  export default defineComponent({
+    attributes: {
+      ariaLabel: { type: String, default: 'Page navigation' },
+      currentPage: { type: Number, default: 1 },
+      totalPages: { type: Number, default: 1 },
+      maxVisible: { type: Number, default: 5 },
+      baseUrl: { type: String, default: '' },
+      urlPrefix: { type: String, default: '' },
+      segment: { type: String, default: 'page' },
+      ellipsis: { type: String, default: '...' }
+    },
+    getters: {
+      paginationLinks: (state) => {
+        const getPageUrl = (page) => {
+          if (page === 1) {
+            return state.baseUrl;
+          }
+
+          const cleanPrefix = state.urlPrefix.endsWith('/') ? state.urlPrefix : `${state.urlPrefix}/`;
+          return `${cleanPrefix}${state.segment}/${page}.html`;
+        }
+
+        const createItem = (page, text, isActive, isDisabled) => {
+          let className = 'page-item';
+          if (isActive) className += ' active';
+          if (isDisabled) className += ' disabled';
+
+          let attr = '';
+          if (isActive) attr += ' aria-current="page"';
+          if (isDisabled) attr += ' tabindex="-1" aria-disabled="true"';
+
+          const href = isDisabled ? '#' : getPageUrl(page);
+
+          return `<li class="${className}"><a class="page-link" href="${href}"${attr}>${text}</a></li>`;
+        }
+
+        let links = '';
+
+        // Previous Link
+        links += createItem(state.currentPage - 1, 'Previous', false, state.currentPage <= 1);
+
+        // Calculate Window (Start/End)
+        const half = Math.floor(state.maxVisible / 2);
+        let start = state.currentPage - half;
+        let end = state.currentPage + half;
+
+        if (start < 1) {
+          start = 1;
+          end = Math.min(state.totalPages, state.maxVisible);
+        }
+
+        if (end > state.totalPages) {
+          end = state.totalPages;
+          start = Math.max(1, state.totalPages - state.maxVisible + 1);
+        }
+
+        const showFirst = start > 1;
+        const showLast = end < state.totalPages;
+
+        // First page + ellipsis
+        if (showFirst) {
+          links += createItem(1, '1', false, false);
+          if (start > 2) {
+            links += `<li class="page-item disabled"><span class="page-link">${state.ellipsis}</span></li>`;
+          }
+        }
+
+        // Main window loop
+        for (let i = start; i <= end; i++) {
+          links += createItem(i, i, i === state.currentPage, false);
+        }
+
+        // Last page + ellipsis
+        if (showLast) {
+          if (end < state.totalPages - 1) {
+            links += `<li class="page-item disabled"><span class="page-link">${state.ellipsis}</span></li>`;
+          }
+          links += createItem(state.totalPages, state.totalPages, false, false);
+        }
+
+        // Next Link
+        links += createItem(state.currentPage + 1, 'Next', false, state.currentPage >= state.totalPages);
+
+        return links;
+      }
+    }
+  })
+</script>

package/lib/index.js

@@ -1,286 +1,243 @@
 import { definePlugin } from 'coralite'
 import path from 'node:path'
 
-/**
- * Aggregates content based on configuration
- * @param {import('../types/index.js').AggregationOptions} options
- * @param {Object} contextInstance
- * @returns {Promise<any[]>}
- */
-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
-
-  // 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)
+export const aggregation = definePlugin({
+  name: 'aggregation',
+
+  async exports(options) {
+    const {
+      path: paths = [],
+      component,
+      pagination,
+      filter,
+      sort,
+      limit,
+      offset = 0,
+      recursive = false,
+      transformState
+    } = options
+    const state = this.state || {}
+    const app = this.app
+    const pagesRoot = app.options.pages
+
+    // Collect pages
+    let allPages = []
+    const uniquePaths = new Set()
+
+    for (const relativePath of paths) {
+      const targetPath = path.join(pagesRoot, relativePath)
+
+      if (!recursive) {
+        const pagesInDir = app.pages.getListByPath(targetPath)
+
+        if (pagesInDir) {
+          for (const page of pagesInDir) {
+            const pagePath = page.path.pathname
+
+            if (!uniquePaths.has(pagePath)) {
+              uniquePaths.add(pagePath)
+              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)
+      } else {
+        // Recursive search
+        for (const page of app.pages.list) {
+          const dirname = page.path.dirname
+
+          if (dirname === targetPath || dirname.startsWith(targetPath + path.sep)) {
+            const pagePath = page.path.pathname
+
+            if (!uniquePaths.has(pagePath)) {
+              uniquePaths.add(pagePath)
+              allPages.push(page)
+            }
           }
         }
       }
     }
-  }
-
-  // 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)
-    })
-  }
-
-  // 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)
-    })
-  }
-
-  // Pagination
-  let startIndex = offset
-  let endIndex = allPages.length
-
-  let currentPage = 1
-  let totalPages = 1
-
-  // Ensure renderContext is available
-  const currentRenderContext = contextInstance.renderContext
-  const buildId = currentRenderContext && currentRenderContext.buildId
-
-  if (limit) {
-    if (pagination) {
-      const segment = pagination.segment || 'page'
-      const urlPathname = contextValues.page_url_pathname || ''
 
-      const escapedSegment = segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    // Filter
+    if (typeof filter === 'function') {
+      allPages = allPages.filter(page => {
+        return filter(page.result.state)
+      })
+    }
 
-      // Try to match segment in URL: /.../segment/Number
-      const segmentRegex = new RegExp(`/${escapedSegment}/(\\d+)`)
-      const match = urlPathname.match(segmentRegex)
+    // Sort
+    if (typeof sort === 'function') {
+      allPages.sort((a, b) => {
+        const propsA = (a.result && a.result.state) ? a.result.state : a.state
+        const propsB = (b.result && b.result.state) ? b.result.state : b.state
+        return sort(propsA, propsB)
+      })
+    }
 
-      if (match) {
-        currentPage = parseInt(match[1], 10)
-      }
+    // Pagination
+    let startIndex = offset
+    let endIndex = allPages.length
 
-      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.component
-        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)
+    let currentPage = 1
+    let totalPages = 1
+
+    const currentRenderContext = this.renderContext
+    const buildId = currentRenderContext && currentRenderContext.buildId
+
+    if (limit) {
+      if (pagination) {
+        const segment = pagination.segment || 'page'
+        const urlPathname = this.page.url.pathname
 
-          // e.g. /blog.html -> /blog/
-          urlPrefixBase = urlPathname.replace(path.extname(currentFilename), '')
+        const escapedSegment = segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+        const segmentRegex = new RegExp(`/${escapedSegment}/(\\d+)`)
+        const match = urlPathname.match(segmentRegex)
+
+        if (match) {
+          currentPage = parseInt(match[1], 10)
         }
 
-        // 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.
+        startIndex = offset + (currentPage - 1) * limit
+        endIndex = startIndex + limit
+        totalPages = Math.ceil(allPages.length / limit)
+
+        if (!match && currentPage === 1 && totalPages > 1 && buildId) {
+          const currentPathname = this.page.file.pathname
+          const currentFilename = this.page.file.filename
+          const currentDirname = this.page.file.dirname
+
+          let targetDir = currentDirname
+          let urlPrefixBase = ''
+
+          if (currentFilename === 'index.html') {
+            targetDir = currentDirname
+            urlPrefixBase = path.dirname(urlPathname)
+          } else {
+            const basename = path.basename(currentFilename, path.extname(currentFilename))
+            targetDir = path.join(currentDirname, basename)
+            urlPrefixBase = urlPathname.replace(path.extname(currentFilename), '')
+          }
 
-        if (currentFilename === 'index.html') {
-          // 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 += '/'
-        }
 
-        // 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 (currentFilename === 'index.html') {
+            urlPrefixBase = path.dirname(urlPathname)
+            if (!urlPrefixBase.endsWith('/')) urlPrefixBase += '/'
           }
 
-          // Add to queue
-          await this.addRenderQueue(virtualItem, buildId)
+          const currentItem = app.pages.getItem(currentPathname)
+
+          for (let i = 2; i <= totalPages; i++) {
+            const newPathname = path.join(targetDir, segment, `${i}.html`)
+
+            const virtualItem = {
+              content: currentItem ? currentItem.content : '',
+              path: {
+                pathname: newPathname,
+                dirname: path.dirname(newPathname),
+                filename: path.basename(newPathname)
+              },
+              state: {
+                paginationBaseUrl: urlPathname,
+                paginationUrlPrefix: urlPrefixBase
+              },
+              type: 'page'
+            }
+
+            await app.addRenderQueue(virtualItem, buildId)
+          }
         }
+      } else {
+        endIndex = Math.min(startIndex + limit, allPages.length)
       }
-    } else {
-      // Simple limit/offset without pagination logic
-      endIndex = Math.min(startIndex + limit, allPages.length)
     }
-  }
-
-  const paginatedPages = allPages.slice(startIndex, endIndex)
-  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)
+
+    const paginatedPages = allPages.slice(startIndex, endIndex)
+    const resultNodes = []
+
+    for (const page of paginatedPages) {
+      const pageProps = (page.result && page.result.state) ? page.result.state : page.state
+      let itemProps = { ...pageProps }
+
+      // Apply properties transformations
+      if (transformState && typeof transformState === 'object') {
+        for (const key in transformState) {
+          if (Object.prototype.hasOwnProperty.call(transformState, key)) {
+            const transform = transformState[key]
+            if (typeof transform === 'string') {
+              itemProps[key] = pageProps[transform]
+            } else if (typeof transform === 'function') {
+              itemProps[key] = transform(pageProps)
+            }
           }
         }
       }
-    }
 
-    // Render the item template
-    if (template) {
-      const component = await this.createComponentElement({
-        id: template,
-        values: itemValues,
-        component: contextInstance.component,
-        renderContext: currentRenderContext
-      })
+      if (component) {
+        const componentElement = await app.createComponentElement({
+          id: component,
+          state: itemProps,
+          page: this.page,
+          renderContext: currentRenderContext
+        })
 
-      if (component && component.children) {
-        resultNodes.push(...component.children)
+        if (componentElement && componentElement.children) {
+          resultNodes.push(...componentElement.children)
+        }
       }
     }
-  }
 
-  // Render pagination controls
-  if (pagination) {
-    const segment = pagination.segment || 'page'
-    const escapedSegment = segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-
-    const paginationTemplateId = pagination.template || 'coralite-pagination'
+    if (pagination) {
+      const paginationComponentId = pagination.component || 'coralite-pagination'
+      const urlPathname = this.page.url.pathname
 
-    // Construct baseUrl and urlPrefix for template
-    const urlPathname = contextValues.page_url_pathname
-    let baseUrl = urlPathname
-    let urlPrefix = ''
+      let baseUrl = urlPathname
+      let urlPrefix = ''
 
-    if (contextValues.meta_pagination_base_url) {
-      baseUrl = contextValues.meta_pagination_base_url
-    }
+      if (state.paginationBaseUrl) {
+        baseUrl = state.paginationBaseUrl
+      }
 
-    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)
+      if (state.paginationUrlPrefix) {
+        urlPrefix = state.paginationUrlPrefix
       } else {
-        // Named file
-        const basename = path.basename(baseUrl, '.html')
-        urlPrefix = path.join(path.dirname(baseUrl), basename)
+        if (baseUrl.endsWith('/index.html') || baseUrl.endsWith('/')) {
+          urlPrefix = path.dirname(baseUrl)
+        } else {
+          const basename = path.basename(baseUrl, '.html')
+          urlPrefix = path.join(path.dirname(baseUrl), basename)
+        }
       }
-    }
 
-    // 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 || '...'
-    }
+      if (!urlPrefix.endsWith('/')) urlPrefix += '/'
+
+      const paginationProps = {
+        '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.createComponentElement({
-      id: paginationTemplateId,
-      values: paginationValues,
-      component: contextInstance.component,
-      renderContext: currentRenderContext
-    })
+      const componentElement = await app.createComponentElement({
+        id: paginationComponentId,
+        state: paginationProps,
+        page: this.page,
+        renderContext: currentRenderContext
+      })
 
-    if (component && component.children) {
-      resultNodes.push(...component.children)
+      if (componentElement && componentElement.children) {
+        resultNodes.push(...componentElement.children)
+      }
     }
-  }
-
-  return resultNodes
-}
 
-export const aggregation = definePlugin({
-  name: 'aggregation',
-  method: aggregationMethod,
+    return resultNodes
+  },
   components: [
     // @ts-ignore
-    path.join(import.meta.dirname, 'templates/coralite-pagination.html')
+    path.join(import.meta.dirname, 'components/coralite-pagination.html')
   ]
 })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coralite-plugin-aggregation",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "A Coralite plugin for dynamically collecting, filtering, sorting, and displaying content across multiple sources. Build database-free Coralite websites with automated content aggregation.",
   "type": "module",
   "keywords": [
@@ -39,14 +39,11 @@
     "lib",
     "types"
   ],
-  "peerDependencies": {
-    "coralite": "^0.32.0"
-  },
-  "license": "AGPL-3.0-only",
+  "license": "MPL-2.0",
   "devDependencies": {
     "@stylistic/eslint-plugin-js": "^4.2.0",
     "@stylistic/eslint-plugin-plus": "^4.2.0",
-    "coralite": "^0.32.0"
+    "coralite": "^0.34.0"
   },
   "scripts": {
     "test": "node --test ./tests/index.spec.js"

package/types/index.js

@@ -10,14 +10,14 @@
 /**
  * @typedef {Object} AggregationOptions
  * @property {string[]} [path=[]] - An array of relative paths to search for pages within `pagesRoot`.
- * @property {string} [template] - The component ID to use for rendering each item found.
+ * @property {string} [component] - The component ID to use for rendering each item found.
  * @property {AggregationPaginationOptions} [pagination] - Configuration for pagination logic and controls. If present, pagination logic is enabled.
  * @property {function(Object): boolean} [filter] - A callback function to filter pages. It receives the page values object and should return `true` to keep the item.
  * @property {function(Object, Object): number} [sort] - A comparison function for sorting pages. It receives two page value objects (a, b) and should return a number.
  * @property {number} [limit] - The maximum number of items to return (or items per page if pagination is used).
  * @property {number} [offset=0] - The starting index for fetching items.
  * @property {boolean} [recursive=false] - If true, searches subdirectories of the specified paths.
- * @property {Object.<string, (string|function(Object): *)>} [tokens] - A map of key transformations. Keys are the new property names. Values can be a string (source property name) or a function (receiving page values and returning the new value).
+ * @property {Object.<string, (string|function(Object): *)>} [transformState] - A map of key transformations. Keys are the new property names. Values can be a string (source property name) or a function (receiving page values and returning the new value).
  */
 
 export default {}