coralite-plugin-aggregation 0.7.3 → 0.9.0

package/lib/components/coralite-pagination.html

@@ -0,0 +1,104 @@
+<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({
+    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
+        }
+        
+        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'
+
+        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(currentPage - 1, 'Previous', false, currentPage <= 1)
+
+      // Calculate Window (Start/End)
+      const half = Math.floor(maxVisible / 2)
+      let start = currentPage - half
+      let end = currentPage + half
+
+      if (start < 1) {
+        start = 1
+        end = Math.min(totalPages, maxVisible)
+      }
+
+      if (end > totalPages) {
+        end = totalPages
+        start = Math.max(1, totalPages - maxVisible + 1)
+      }
+
+      const showFirst = start > 1
+      const showLast = end < 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>`
+        }
+      }
+
+      // Main window loop
+      for (let i = start; i <= end; i++) {
+        links += createItem(i, i, i === currentPage, false)
+      }
+
+      // Last page + ellipsis
+      if (showLast) {
+        if (end < totalPages - 1) {
+          links += `<li class="page-item disabled"><span class="page-link">${ellipsis}</span></li>`
+        }
+        links += createItem(totalPages, totalPages, false, false)
+      }
+
+      // Next Link
+      links += createItem(currentPage + 1, 'Next', false, currentPage >= totalPages)
+
+      return {
+        ariaLabel,
+        paginationLinks: links
+      }
+    }
+  })
+</script>

package/lib/index.js

@@ -4,12 +4,12 @@ import path from 'node:path'
 /**
  * Aggregates content based on configuration
  * @param {import('../types/index.js').AggregationOptions} options
- * @param {Object} contextInstance
+ * @param {Object} context
  * @returns {Promise<any[]>}
  */
-async function aggregationMethod (options, contextInstance) {
+async function aggregationMethod (options, context) {
   const {
-    path: paths = [],
+  path: paths = [],
     template,
     pagination,
     filter,
@@ -17,10 +17,10 @@ async function aggregationMethod (options, contextInstance) {
     limit,
     offset = 0,
     recursive = false,
-    tokens
+    transformProperties
   } = options
 
-  const contextValues = contextInstance.values
+  const contextProperties = context.properties || {}
   const pagesRoot = this.options.pages
 
   // Collect pages
@@ -30,13 +30,13 @@ async function aggregationMethod (options, contextInstance) {
   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)
+          const pagePath = page.url ? page.url.pathname : page.path.pathname
+          if (!uniquePaths.has(pagePath)) {
+            uniquePaths.add(pagePath)
             allPages.push(page)
           }
         }
@@ -44,11 +44,11 @@ async function aggregationMethod (options, contextInstance) {
     } 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
+        const dirname = page.file ? page.file.dirname : page.path.dirname
         if (dirname === targetPath || dirname.startsWith(targetPath + path.sep)) {
-          if (!uniquePaths.has(page.path.pathname)) {
-            uniquePaths.add(page.path.pathname)
+          const pagePath = page.url ? page.url.pathname : page.path.pathname
+          if (!uniquePaths.has(pagePath)) {
+            uniquePaths.add(pagePath)
             allPages.push(page)
           }
         }
@@ -59,18 +59,17 @@ async function aggregationMethod (options, contextInstance) {
   // 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)
+      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 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)
+      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)
     })
   }
 
@@ -81,18 +80,15 @@ async function aggregationMethod (options, contextInstance) {
   let currentPage = 1
   let totalPages = 1
 
-  // Ensure renderContext is available
-  const currentRenderContext = contextInstance.renderContext
+  const currentRenderContext = context.renderContext
   const buildId = currentRenderContext && currentRenderContext.buildId
 
   if (limit) {
     if (pagination) {
       const segment = pagination.segment || 'page'
-      const urlPathname = contextValues.$urlPathname || ''
+      const urlPathname = context.page.url.pathname
 
       const escapedSegment = segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-
-      // Try to match segment in URL: /.../segment/Number
       const segmentRegex = new RegExp(`/${escapedSegment}/(\\d+)`)
       const match = urlPathname.match(segmentRegex)
 
@@ -102,81 +98,55 @@ async function aggregationMethod (options, contextInstance) {
 
       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
+        const currentPathname = context.page.file.pathname
+        const currentFilename = context.page.file.filename
+        const currentDirname = context.page.file.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/
+          urlPrefixBase = path.dirname(urlPathname)
         } else {
-          // Named file: create subdirectory with same name (minus extension)
           const basename = path.basename(currentFilename, path.extname(currentFilename))
           targetDir = path.join(currentDirname, basename)
-
-          // e.g. /blog.html -> /blog/
           urlPrefixBase = urlPathname.replace(path.extname(currentFilename), '')
         }
 
-        // 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') {
-          // 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)
+        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 : '', // Use original content
+            content: currentItem ? currentItem.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
+            properties: {
+              paginationBaseUrl: urlPathname,
+              paginationUrlPrefix: urlPrefixBase
             },
             type: 'page'
           }
 
-          // Add to queue
           await this.addRenderQueue(virtualItem, buildId)
         }
       }
     } else {
-      // Simple limit/offset without pagination logic
       endIndex = Math.min(startIndex + limit, allPages.length)
     }
   }
@@ -185,29 +155,28 @@ async function aggregationMethod (options, contextInstance) {
   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]
+    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') {
-            itemValues[key] = pageValues[transform]
+            itemProps[key] = pageProps[transform]
           } else if (typeof transform === 'function') {
-            itemValues[key] = transform(pageValues)
+            itemProps[key] = transform(pageProps)
           }
         }
       }
     }
 
-    // Render the item template
     if (template) {
       const component = await this.createComponentElement({
         id: template,
-        values: itemValues,
-        component: contextInstance.component,
+        properties: itemProps,
+        page: context.page,
         renderContext: currentRenderContext
       })
 
@@ -217,39 +186,31 @@ async function aggregationMethod (options, contextInstance) {
     }
   }
 
-  // Render pagination controls
   if (pagination) {
-    const segment = pagination.segment || 'page'
-    const escapedSegment = segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-
     const paginationTemplateId = pagination.template || 'coralite-pagination'
-
-    // Construct baseUrl and urlPrefix for template
-    const urlPathname = contextValues.$urlPathname
+    const urlPathname = context.page.url.pathname
+    
     let baseUrl = urlPathname
     let urlPrefix = ''
 
-    if (contextValues.meta_pagination_base_url) {
-      baseUrl = contextValues.meta_pagination_base_url
+    if (contextProperties.paginationBaseUrl) {
+      baseUrl = contextProperties.paginationBaseUrl
     }
 
-    if (contextValues.meta_pagination_url_prefix) {
-      urlPrefix = contextValues.meta_pagination_url_prefix
+    if (contextProperties.paginationUrlPrefix) {
+      urlPrefix = contextProperties.paginationUrlPrefix
     } 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)
       }
     }
 
-    // Normalize urlPrefix to ensure trailing slash
     if (!urlPrefix.endsWith('/')) urlPrefix += '/'
 
-    const paginationValues = {
+    const paginationProps = {
       'current-page': String(currentPage),
       'total-pages': String(totalPages),
       'base-url': baseUrl,
@@ -262,8 +223,8 @@ async function aggregationMethod (options, contextInstance) {
 
     const component = await this.createComponentElement({
       id: paginationTemplateId,
-      values: paginationValues,
-      component: contextInstance.component,
+      properties: paginationProps,
+      page: context.page,
       renderContext: currentRenderContext
     })
 
@@ -279,8 +240,9 @@ export const aggregation = definePlugin({
   name: 'aggregation',
   method: aggregationMethod,
   components: [
-    path.join(import.meta.dirname, 'templates/coralite-pagination.html')
+    // @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.7.3",
+  "version": "0.9.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.31.7"
-  },
-  "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.31.7"
+    "coralite": "^0.33.1"
   },
   "scripts": {
     "test": "node --test ./tests/index.spec.js"

package/types/index.js

@@ -17,7 +17,7 @@
  * @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): *)>} [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).
  */
 
 export default {}

package/lib/templates/coralite-pagination.html

@@ -1,123 +0,0 @@
-<template id="coralite-pagination">
-  <nav aria-label="{{ ariaLabel }}">
-    <ul class="pagination">
-      {{ paginationLinks }}
-    </ul>
-  </nav>
-</template>
-
-<script type="module">
-  import { defineComponent } from 'coralite'
-
-  export default defineComponent({
-    tokens: {
-      ariaLabel(context) {
-        return context['aria-label'] || 'Page navigation'
-      },
-      /**
-       * Generates HTML pagination links based on the provided context.
-       *
-       * @param {Object} context - The context object containing pagination details.
-       * @param {string} context['current-page'] - The current page number (1-based).
-       * @param {string} context['total-pages'] - The total number of pages.
-       * @param {string} context['base-url'] - The explicit URL for Page 1 (e.g., '/blog.html').
-       * @param {string} context['url-prefix'] - The directory prefix for paginated segments (e.g., '/blog').
-       * @param {string} [context.segment='page'] - The URL segment for pagination (default: 'page').
-       * @param {string} [context.max-visible='5'] - Max number of direct page links to show.
-       * @param {string} [context.ellipsis='...'] - Text to display for skipped pages.
-       * @returns {string} - A string containing the HTML <li> elements.
-       */
-      paginationLinks(context) {
-        // Parse inputs with defaults
-        const currentPage = parseInt(context['current-page'] || '1', 10)
-        const totalPages = parseInt(context['total-pages'] || '1', 10)
-        const maxVisible = parseInt(context['max-visible'] || '5', 10)
-        
-        const baseUrl = context['base-url'] || ''
-        const urlPrefix = context['url-prefix'] || ''
-        const segment = context['segment'] || 'page'
-        const ellipsis = context['ellipsis'] || '...'
-
-        /**
-         * Constructs the URL for a specific page.
-         * 1. Page 1 links strictly to `base-url` (canonical root).
-         * 2. Pages > 1 follow the pattern: `{url-prefix}/{segment}/{page}.html`.
-         */
-        const getPageUrl = (page) => {
-          if (page === 1) {
-            return baseUrl
-          }
-          
-          // Ensure prefix has a trailing slash for concatenation
-          const cleanPrefix = urlPrefix.endsWith('/') ? urlPrefix : `${urlPrefix}/`
-          return `${cleanPrefix}${segment}/${page}.html`
-        }
-
-        // Helper to generate list items
-        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(currentPage - 1, 'Previous', false, currentPage <= 1)
-
-        // Calculate Window (Start/End)
-        const half = Math.floor(maxVisible / 2)
-        let start = currentPage - half
-        let end = currentPage + half
-
-        if (start < 1) {
-          start = 1
-          end = Math.min(totalPages, maxVisible)
-        }
-
-        if (end > totalPages) {
-          end = totalPages
-          start = Math.max(1, totalPages - maxVisible + 1)
-        }
-
-        // Render Pages with ellipsis
-        const showFirst = start > 1
-        const showLast = end < totalPages
-
-        // First page + ellipsis if window doesn't touch start
-        if (showFirst) {
-          links += createItem(1, '1', false, false)
-          if (start > 2) {
-            links += `<li class="page-item disabled"><span class="page-link">${ellipsis}</span></li>`
-          }
-        }
-
-        // Main window loop
-        for (let i = start; i <= end; i++) {
-          links += createItem(i, i, i === currentPage, false)
-        }
-
-        // Last page + ellipsis if window doesn't touch end
-        if (showLast) {
-          if (end < totalPages - 1) {
-            links += `<li class="page-item disabled"><span class="page-link">${ellipsis}</span></li>`
-          }
-          links += createItem(totalPages, totalPages, false, false)
-        }
-
-        // Next Link
-        links += createItem(currentPage + 1, 'Next', false, currentPage >= totalPages)
-
-        return links
-      }
-    }
-  })
-</script>