coralite-plugin-aggregation 0.9.0 → 0.10.0

package/lib/components/coralite-pagination.html

@@ -10,95 +10,90 @@
   import { defineComponent } from 'coralite/plugins'
 
   export default defineComponent({
-    properties: (context) => {
-      const props = context.properties
-      
-      const ariaLabel = props['aria-label'] || 'Page navigation'
-      
-      const currentPage = parseInt(props['current-page'] || '1', 10)
-      const totalPages = parseInt(props['total-pages'] || '1', 10)
-      const maxVisible = parseInt(props['max-visible'] || '5', 10)
-      
-      const baseUrl = props['base-url'] || ''
-      const urlPrefix = props['url-prefix'] || ''
-      const segment = props['segment'] || 'page'
-      const ellipsis = props['ellipsis'] || '...'
-
-      // Compute pagination synchronously
-      const getPageUrl = (page) => {
-        if (page === 1) {
-          return baseUrl
+    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 cleanPrefix = urlPrefix.endsWith('/') ? urlPrefix : `${urlPrefix}/`
-        return `${cleanPrefix}${segment}/${page}.html`
-      }
 
-      const createItem = (page, text, isActive, isDisabled) => {
-        let className = 'page-item'
-        if (isActive) className += ' active'
-        if (isDisabled) className += ' disabled'
+        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"'
+          let attr = '';
+          if (isActive) attr += ' aria-current="page"';
+          if (isDisabled) attr += ' tabindex="-1" aria-disabled="true"';
 
-        const href = isDisabled ? '#' : getPageUrl(page)
+          const href = isDisabled ? '#' : getPageUrl(page);
 
-        return `<li class="${className}"><a class="page-link" href="${href}"${attr}>${text}</a></li>`
-      }
+          return `<li class="${className}"><a class="page-link" href="${href}"${attr}>${text}</a></li>`;
+        }
 
-      let links = ''
+        let links = '';
 
-      // Previous Link
-      links += createItem(currentPage - 1, 'Previous', false, currentPage <= 1)
+        // Previous Link
+        links += createItem(state.currentPage - 1, 'Previous', false, state.currentPage <= 1);
 
-      // Calculate Window (Start/End)
-      const half = Math.floor(maxVisible / 2)
-      let start = currentPage - half
-      let end = currentPage + half
+        // 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(totalPages, maxVisible)
-      }
+        if (start < 1) {
+          start = 1;
+          end = Math.min(state.totalPages, state.maxVisible);
+        }
 
-      if (end > totalPages) {
-        end = totalPages
-        start = Math.max(1, totalPages - maxVisible + 1)
-      }
+        if (end > state.totalPages) {
+          end = state.totalPages;
+          start = Math.max(1, state.totalPages - state.maxVisible + 1);
+        }
 
-      const showFirst = start > 1
-      const showLast = end < totalPages
+        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">${ellipsis}</span></li>`
+        // 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 === currentPage, false)
-      }
+        // 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 < totalPages - 1) {
-          links += `<li class="page-item disabled"><span class="page-link">${ellipsis}</span></li>`
+        // 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);
         }
-        links += createItem(totalPages, totalPages, false, false)
-      }
 
-      // Next Link
-      links += createItem(currentPage + 1, 'Next', false, currentPage >= totalPages)
+        // Next Link
+        links += createItem(state.currentPage + 1, 'Next', false, state.currentPage >= state.totalPages);
 
-      return {
-        ariaLabel,
-        paginationLinks: links
+        return links;
       }
     }
   })
-</script>
+</script>

package/lib/index.js

@@ -1,248 +1,244 @@
 import { definePlugin } from 'coralite'
 import path from 'node:path'
 
-/**
- * Aggregates content based on configuration
- * @param {import('../types/index.js').AggregationOptions} options
- * @param {Object} context
- * @returns {Promise<any[]>}
- */
-async function aggregationMethod (options, context) {
-  const {
-  path: paths = [],
-    template,
-    pagination,
-    filter,
-    sort,
-    limit,
-    offset = 0,
-    recursive = false,
-    transformProperties
-  } = options
-
-  const contextProperties = context.properties || {}
-  const pagesRoot = this.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 = this.pages.getListByPath(targetPath)
-      if (pagesInDir) {
-        for (const page of pagesInDir) {
-          const pagePath = page.url ? page.url.pathname : page.path.pathname
-          if (!uniquePaths.has(pagePath)) {
-            uniquePaths.add(pagePath)
-            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.file ? page.file.dirname : page.path.dirname
-        if (dirname === targetPath || dirname.startsWith(targetPath + path.sep)) {
-          const pagePath = page.url ? page.url.pathname : page.path.pathname
-          if (!uniquePaths.has(pagePath)) {
-            uniquePaths.add(pagePath)
-            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 => {
-      const pageProps = (page.result && page.result.properties) ? page.result.properties : page.properties
-      return filter(pageProps)
-    })
-  }
-
-  // Sort
-  if (typeof sort === 'function') {
-    allPages.sort((a, b) => {
-      const propsA = (a.result && a.result.properties) ? a.result.properties : a.properties
-      const propsB = (b.result && b.result.properties) ? b.result.properties : b.properties
-      return sort(propsA, propsB)
-    })
-  }
-
-  // Pagination
-  let startIndex = offset
-  let endIndex = allPages.length
-
-  let currentPage = 1
-  let totalPages = 1
-
-  const currentRenderContext = context.renderContext
-  const buildId = currentRenderContext && currentRenderContext.buildId
-
-  if (limit) {
-    if (pagination) {
-      const segment = pagination.segment || 'page'
-      const urlPathname = context.page.url.pathname
 
-      const escapedSegment = segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-      const segmentRegex = new RegExp(`/${escapedSegment}/(\\d+)`)
-      const match = urlPathname.match(segmentRegex)
+    // Filter
+    if (typeof filter === 'function') {
+      allPages = allPages.filter(page => {
+        return filter(page.result.state)
+      })
+    }
+
+    // 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)
+    let currentPage = 1
+    let totalPages = 1
 
-      if (!match && currentPage === 1 && totalPages > 1 && buildId) {
-        const currentPathname = context.page.file.pathname
-        const currentFilename = context.page.file.filename
-        const currentDirname = context.page.file.dirname
+    const currentRenderContext = this.renderContext
+    const buildId = currentRenderContext && currentRenderContext.buildId
 
-        let targetDir = currentDirname
-        let urlPrefixBase = ''
+    if (limit) {
+      if (pagination) {
+        const segment = pagination.segment || 'page'
+        const urlPathname = this.page.url.pathname
 
-        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), '')
+        const escapedSegment = segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+        const segmentRegex = new RegExp(`/${escapedSegment}/(\\d+)`)
+        const match = urlPathname.match(segmentRegex)
+
+        if (match) {
+          currentPage = parseInt(match[1], 10)
         }
 
-        if (!urlPrefixBase.endsWith('/')) urlPrefixBase += '/'
+        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') {
-          urlPrefixBase = path.dirname(urlPathname)
           if (!urlPrefixBase.endsWith('/')) urlPrefixBase += '/'
-        }
 
-        const currentItem = this.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)
-            },
-            properties: {
-              paginationBaseUrl: urlPathname,
-              paginationUrlPrefix: urlPrefixBase
-            },
-            type: 'page'
+          if (currentFilename === 'index.html') {
+            urlPrefixBase = path.dirname(urlPathname)
+            if (!urlPrefixBase.endsWith('/')) urlPrefixBase += '/'
           }
 
-          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 {
-      endIndex = Math.min(startIndex + limit, allPages.length)
     }
-  }
-
-  const paginatedPages = allPages.slice(startIndex, endIndex)
-  const resultNodes = []
-
-  for (const page of paginatedPages) {
-    const pageProps = (page.result && page.result.properties) ? page.result.properties : page.properties
-    let itemProps = { ...pageProps }
-
-    // Apply properties transformations
-    if (transformProperties && typeof transformProperties === 'object') {
-      for (const key in transformProperties) {
-        if (Object.prototype.hasOwnProperty.call(transformProperties, key)) {
-          const transform = transformProperties[key]
-          if (typeof transform === 'string') {
-            itemProps[key] = pageProps[transform]
-          } else if (typeof transform === 'function') {
-            itemProps[key] = transform(pageProps)
+
+    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)
+            }
           }
         }
       }
-    }
 
-    if (template) {
-      const component = await this.createComponentElement({
-        id: template,
-        properties: itemProps,
-        page: context.page,
-        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)
+        }
       }
     }
-  }
 
-  if (pagination) {
-    const paginationTemplateId = pagination.template || 'coralite-pagination'
-    const urlPathname = context.page.url.pathname
-    
-    let baseUrl = urlPathname
-    let urlPrefix = ''
+    if (pagination) {
+      const paginationComponentId = pagination.component || 'coralite-pagination'
+      const urlPathname = this.page.url.pathname
 
-    if (contextProperties.paginationBaseUrl) {
-      baseUrl = contextProperties.paginationBaseUrl
-    }
+      let baseUrl = urlPathname
+      let urlPrefix = ''
 
-    if (contextProperties.paginationUrlPrefix) {
-      urlPrefix = contextProperties.paginationUrlPrefix
-    } else {
-      if (baseUrl.endsWith('/index.html') || baseUrl.endsWith('/')) {
-        urlPrefix = path.dirname(baseUrl)
+      if (state.paginationBaseUrl) {
+        baseUrl = state.paginationBaseUrl
+      }
+
+      if (state.paginationUrlPrefix) {
+        urlPrefix = state.paginationUrlPrefix
       } else {
-        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)
+        }
       }
-    }
 
-    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 || '...'
-    }
+      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,
-      properties: paginationProps,
-      page: context.page,
-      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, 'components/coralite-pagination.html')
   ]
 })
 
-export default aggregation
+export default aggregation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coralite-plugin-aggregation",
-  "version": "0.9.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": [
@@ -43,7 +43,7 @@
   "devDependencies": {
     "@stylistic/eslint-plugin-js": "^4.2.0",
     "@stylistic/eslint-plugin-plus": "^4.2.0",
-    "coralite": "^0.33.1"
+    "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): *)>} [transformProperties] - 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 {}