coralite 0.6.4 → 0.6.6

package/change-logs.md

@@ -1,3 +1,39 @@
+# 🎁 Release notes (`v0.6.6`)
+
+## Changes
+- 790c585 (HEAD -> main, tag: v0.6.6, origin/main) fix: computedSlots token param includes attrib values - (*Thomas David*)
+- 505d4f0 feat: export parseHTML util - (*Thomas David*)
+- d0fc52d docs: update CoraliteModuleValues type - (*Thomas David*)
+- 6ad27ce feat: tokens parse HTML - (*Thomas David*)
+- 9497c25 feat: export current document to template context - (*Thomas David*)
+- df9a1a5 refactor: create reusable parseHTML function - (*Thomas David*)
+- ebb388c feat: append rendered token to custom element slots - (*Thomas David*)
+- 1f6ffd0 feat: add filtering to aggregate function - (*Thomas David*)
+
+## Metadata
+```
+This version -------- v0.6.6
+Previous version ---- v0.6.5
+Total commits ------- 8
+```
+# 🎁 Release notes (`v0.6.5`)
+
+## Changes
+- 4610baa (HEAD -> main, tag: v0.6.5, origin/main) chore: version bump - (*Thomas David*)
+- be2511d ci: remove windows due to unavailability - (*Thomas David*)
+- 821f212 test: cover aggregate filter option - (*Thomas David*)
+- 48eaa76 docs: add CoraliteAggregate to aggregate param - (*Thomas David*)
+- 39ab5ba docs: add CoraliteAggregate typedef - (*Thomas David*)
+- 148dee9 feat: add filter to aggregate function - (*Thomas David*)
+- 15cf0fd docs: add CoraliteAggregate typedef - (*Thomas David*)
+- dbb5b8f feat: remove unused  parseHTMLMeta ignoreByAttribute param - (*Thomas David*)
+
+## Metadata
+```
+This version -------- v0.6.5
+Previous version ---- v0.6.4
+Total commits ------- 8
+```
 # 🎁 Release notes (`v0.6.4`)
 
 ## Changes

package/lib/coralite.js

@@ -5,10 +5,10 @@ import render from 'dom-serializer'
  * @import {
  *  CoraliteElement,
  *  CoraliteTextNode,
- *  CoraliteAggregateTemplate,
  *  CoraliteAnyNode,
  *  CoraliteModule,
- *  CoraliteResult
+ *  CoraliteResult,
+ *  CoraliteAggregate
  * } from '#types'
  */
 
@@ -50,9 +50,7 @@ export async function defineComponent (options) {
 /**
  * Aggregates HTML content from specified paths into a single collection of components.
  *
- * @param {Object} options - Configuration object for the aggregation process
- * @param {CoraliteAggregateTemplate | string} options.template - Templates used to display the result
- * @param {string} options.path - The path to aggregate, relative to pages directory
+ * @param {CoraliteAggregate} options - Configuration object for the aggregation process
  * @returns {Promise<(CoraliteElement | CoraliteTextNode)[]>}
  */
 export async function aggregate (options) {

package/lib/html-module.js

@@ -4,17 +4,13 @@ import { createComponent, parseHTMLMeta } from './parse.js'
 import { existsSync } from 'node:fs'
 
 /**
- * @import { CoraliteTokenOptions, CoraliteModule, CoraliteDocument, CoraliteModuleValues, CoraliteAggregateTemplate } from '#types'
+ * @import { CoraliteTokenOptions, CoraliteModule, CoraliteDocument, CoraliteModuleValues, CoraliteAggregateTemplate, CoraliteAggregate } from '#types'
  */
 
 /**
  * Aggregates HTML content from specified paths into a single collection of components.
  *
- * @param {Object} options - Configuration object for the aggregation process
- * @param {string} options.path - The path to aggregate, relative to pages directory
- * @param {CoraliteAggregateTemplate | string} options.template - Templates used to display the result
- * @param {boolean} [options.recursive] - Whether to recursively search subdirectories
- * @param {CoraliteTokenOptions} [options.tokens] - Token configuration options
+ * @param {CoraliteAggregate} options - Configuration object for the aggregation process
  * @param {CoraliteModuleValues} values - Default token values
  * @param {Object.<string, CoraliteModule>} components - Available components library
  * @param {CoraliteDocument} document - Current document being processed
@@ -66,26 +62,48 @@ export async function aggregate (options, values, components, document) {
 
   for (let i = 0; i < pages.length; i++) {
     const page = pages[i]
-    const meta = parseHTMLMeta(page.content, document.ignoreByAttribute)
+    const meta = parseHTMLMeta(page.content)
     const pageValues = Object.assign({}, values)
+    let isFilter = !!options.filter
+    let ignorePage = false
 
     for (const key in meta) {
       if (Object.prototype.hasOwnProperty.call(meta, key)) {
         const data = meta[key]
+        const content = []
+        const firstItem = data[0]
 
-        for (let i = 0; i < data.length; i++) {
-          const item = data[i]
-          let suffix = ''
+        if (data.length > 1) {
+          for (let i = 0; i < data.length; i++) {
+            const item = data[i]
+            let suffix = ''
 
-          if (i > 0) {
+            if (isFilter && !ignorePage) {
+              ignorePage = options.filter(item)
+            }
             suffix = '_' + i
+
+            if (i === 0) {
+              pageValues[item.name] = item.content
+            }
+
+            pageValues[item.name + suffix] = item.content
+
+            content.push(item.content)
           }
 
-          pageValues[item.name + suffix] = item.content
+          pageValues[firstItem.name + '_list'] = content
+        } else {
+          pageValues[firstItem.name] = firstItem.content
         }
       }
     }
 
+    // break if page is filtered
+    if (isFilter && !ignorePage) {
+      break
+    }
+
     const component = await createComponent({
       id: componentId,
       values: pageValues,

package/lib/parse.js

@@ -3,7 +3,6 @@ import { aggregate } from './html-module.js'
 import vm from 'node:vm'
 import { invalidCustomTags, validTags } from './tags.js'
 
-
 /**
  * @import {Module} from 'node:vm'
  * @import {
@@ -19,8 +18,10 @@ import { invalidCustomTags, validTags } from './tags.js'
  *  CoraliteDocumentRoot,
  *  CoraliteContentNode,
  *  CoraliteModuleValues,
- *  CoraliteAggregateTemplate,
- *  IgnoreByAttribute
+ *  IgnoreByAttribute,
+ *  CoraliteAggregate,
+ *  CoraliteAnyNode,
+ *  CoraliteDirective
  * } from '#types'
  */
 
@@ -28,33 +29,15 @@ const customElementTagRegExp = /^[^-].*[-._a-z0-9\u00B7\u00C0-\u00D6\u00D8-\u00F
 
 const customElementTagTokenRegExp = /^[^-].*[-._a-z0-9\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}\{\}]*$/ui
 
+
 /**
- * Parses HTML content into a Coralite document structure.
+ * Parse HTML content and return a CoraliteDocument object representing the parsed document structure
  *
- * @param {HTMLData} html - The HTML data containing the content to parse
- * @param {CoralitePath} path - The path object containing the file path information
+ * @param {string} string - HTML content to parse as string input type textual data
  * @param {IgnoreByAttribute} [ignoreByAttribute] - Ignore element with attribute name value pair
- * @returns {CoraliteDocument} An object representing the parsed document structure
- *
- * @example
- * ```
- * // Example usage:
- * const html = {
- *   name: 'index.html',
- *   parentPath: 'path/to/parent',
- *   content: '<div>Content</div>'
- * };
- *
- * const path = {
- *   pages: 'path/to/pages',
- *   templates: 'path/to/templates'
- * };
- *
- * const document = parseHTMLDocument(html, path);
- * // document.root will contain parsed elements and text nodes
- * ```
+ * @example parseHTML('<h1>Hello world!</h1>')
  */
-export function parseHTMLDocument (html, path, ignoreByAttribute) {
+export function parseHTML (string, ignoreByAttribute) {
   // root element reference
   /** @type {CoraliteDocumentRoot} */
   const root = {
@@ -115,7 +98,8 @@ export function parseHTMLDocument (html, path, ignoreByAttribute) {
     }
   })
 
-  parser.write(html.content)
+
+  parser.write(string)
   parser.end()
 
   for (let i = 0; i < customElements.length; i++) {
@@ -139,11 +123,46 @@ export function parseHTMLDocument (html, path, ignoreByAttribute) {
     }
   }
 
+  return {
+    root,
+    customElements
+  }
+}
+
+/**
+ * Parses HTML content into a Coralite document structure.
+ *
+ * @param {HTMLData} html - The HTML data containing the content to parse
+ * @param {CoralitePath} path - The path object containing the file path information
+ * @param {IgnoreByAttribute} [ignoreByAttribute] - Ignore element with attribute name value pair
+ * @returns {CoraliteDocument} An object representing the parsed document structure
+ *
+ * @example
+ * ```
+ * // Example usage:
+ * const html = {
+ *   name: 'index.html',
+ *   parentPath: 'path/to/parent',
+ *   content: '<div>Content</div>'
+ * };
+ *
+ * const path = {
+ *   pages: 'path/to/pages',
+ *   templates: 'path/to/templates'
+ * };
+ *
+ * const document = parseHTMLDocument(html, path);
+ * // document.root will contain parsed elements and text nodes
+ * ```
+ */
+export function parseHTMLDocument (html, path, ignoreByAttribute) {
+  const result = parseHTML(html.content, ignoreByAttribute)
+
   return {
     name: html.name,
     parentPath: html.parentPath,
-    root,
-    customElements,
+    root: result.root,
+    customElements: result.customElements,
     path,
     ignoreByAttribute
   }
@@ -153,7 +172,6 @@ export function parseHTMLDocument (html, path, ignoreByAttribute) {
  * Parses HTML string containing meta tags and extracts associated metadata.
  *
  * @param {string} string - HTML content containing meta tags
- * @param {IgnoreByAttribute} ignoreByAttribute - IgnoreByAttribute option (optional) - If provided and true then the HTML tags will be ignored by this attribute name(s)
  * @returns {Object.<string, CoraliteToken[]>}
  *
  * @example
@@ -168,7 +186,7 @@ export function parseHTMLDocument (html, path, ignoreByAttribute) {
  * //}
  * ```
  */
-export function parseHTMLMeta (string, ignoreByAttribute) {
+export function parseHTMLMeta (string) {
   // stack to keep track of current element hierarchy
   const stack = []
   /** @type {Object.<string, CoraliteToken[]>} */
@@ -179,15 +197,6 @@ export function parseHTMLMeta (string, ignoreByAttribute) {
     onopentag (name, attributes) {
       if (name === 'meta') {
         if (attributes.content) {
-          if (ignoreByAttribute) {
-            // ignore meta tags by attribute name
-            const ignore = findAttributesToIgnore(ignoreByAttribute, attributes)
-
-            if (ignore) {
-              return
-            }
-          }
-
           if (attributes.property) {
             addMetadata(meta, attributes.property, attributes.content)
           }
@@ -573,20 +582,32 @@ export async function createComponent ({
           // inject nodes
           const textSplit = node.data.split(computedToken.content)
           const childIndex = node.parent.children.indexOf(node)
+          const children = []
+
+          // append computed tokens in between token split
+          for (let i = 0; i < value.length; i++) {
+            const child = value[i]
+
+            if (typeof child !== 'string') {
+              // update child parent
+              child.parent = node.parent
+              children.push(child)
+            }
+          }
 
+          // replace computed token
           node.parent.children.splice(childIndex, 1,
             {
               type: 'text',
               data: textSplit[0],
               parent: node.parent
             },
-            ...value,
+            ...children,
             {
               type: 'text',
               data: textSplit[1],
               parent: node.parent
-            }
-          )
+            })
         } else {
           // replace token string
           node.data = node.data.replace(computedToken.content, value)
@@ -601,6 +622,27 @@ export async function createComponent ({
 
   for (let i = 0; i < customElements.length; i++) {
     const customElement = customElements[i]
+
+    // update slot elements
+    if (customElement.children
+      && customElement.children.length
+      && !customElement.slots.length
+    ) {
+      for (let i = 0; i < customElement.children.length; i++) {
+        const node = customElement.children[i]
+        const slotElement = {
+          name: 'default',
+          node
+        }
+
+        if (node.attribs && node.attribs.slot) {
+          slotElement.name = node.attribs.slot
+        }
+
+        customElement.slots.push(slotElement)
+      }
+    }
+
     const component = await createComponent({
       id: customElement.name,
       values: Object.assign(values, customElement.attribs),
@@ -676,7 +718,7 @@ export async function createComponent ({
  * @param {CoraliteElement} data.element - Element
  * @param {Object.<string, CoraliteModule>} data.components - Mapping of other components that might be referenced
  * @param {CoraliteDocument} data.document - The current document being processed
- * @returns {Promise<Object.<string,(string|(CoraliteElement|CoraliteTextNode)[])>>}
+ * @returns {Promise<Object.<string,string|(CoraliteDirective|CoraliteAnyNode)[]>>}
  */
 export async function parseScript ({
   component,
@@ -688,16 +730,19 @@ export async function parseScript ({
   const contextifiedObject = vm.createContext({
     crypto: globalThis.crypto,
     coralite: {
+      document,
       tokens: values,
       /**
        * @param {Object} options
        * @param {Object.<string, (string | function)>} options.tokens
        * @param {Object.<string, Function>} options.slots
-       * @returns {Promise<Object.<string, string>>}
+       * @returns {Promise<CoraliteModuleValues>}
        */
       async defineComponent (options) {
-        /** @type {Object.<string, string>} */
-        const tokens = {}
+        /** @type {CoraliteModuleValues} */
+        const tokens = { ...values }
+        const computedTokens = []
+        const computedTokenKey = []
 
         if (options.tokens) {
           for (const key in options.tokens) {
@@ -705,8 +750,48 @@ export async function parseScript ({
               const token = options.tokens[key]
 
               if (typeof token === 'function') {
-                tokens[key] = await token(values)
+                const result = token(values) || ''
+
+                if (result instanceof Promise) {
+                  computedTokens.push(result)
+                  computedTokenKey.push(key)
+                } else {
+                  tokens[key] = result
+                }
+              }
+
+              if (typeof tokens[key] === 'string') {
+                const result = parseHTML(tokens[key], document.ignoreByAttribute)
+                const children = result.root.children
+
+                if (children.length) {
+                  if (children.length === 1 && children[0].type === 'text') {
+                    tokens[key] = children[0].data
+                  } else {
+                    tokens[key] = children
+                  }
+                }
+              }
+
+            }
+          }
+        }
+
+        if (computedTokens.length) {
+          const results = await Promise.all(computedTokens)
+
+          for (let i = 0; i < results.length; i++) {
+            const result = results[i]
+            const key = computedTokenKey[i]
+
+            if (typeof result === 'string') {
+              const html = parseHTML(results[i], document.ignoreByAttribute)
+
+              if (html.root.children.length) {
+                tokens[key] = html.root.children
               }
+            } else {
+              tokens[key] = result
             }
           }
         }
@@ -733,7 +818,7 @@ export async function parseScript ({
               }
 
               // compute slot nodes
-              const result = computedSlot(slotContent, values) || slotContent
+              const result = computedSlot(slotContent, tokens) || slotContent
 
               // append new slot nodes
               for (let index = 0; index < result.length; index++) {
@@ -761,9 +846,7 @@ export async function parseScript ({
        */
 
       /**
-       * @param {Object} options
-       * @param {CoraliteAggregateTemplate} options.template - Templates used to display the result
-       * @param {string} options.path
+       * @param {CoraliteAggregate} options
        */
       async aggregate (options) {
         /** @type {string} */
@@ -809,10 +892,11 @@ export async function parseScript ({
 async function moduleLinker (specifier, referencingModule) {
   if (specifier === 'coralite') {
     return new vm.SourceTextModule(`
+      export const document = coralite.document
       export const tokens = coralite.tokens
       export const defineComponent = coralite.defineComponent
       export const aggregate = coralite.aggregate
-      export default { tokens, defineComponent, aggregate };
+      export default { tokens, defineComponent, aggregate, document };
     `, { context: referencingModule.context })
   }
   const module = await import(specifier)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coralite",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "HTML modules static site generator",
   "main": "./lib/coralite.js",
   "type": "module",

package/types/index.js

@@ -19,7 +19,7 @@
  */
 
 /**
- * @typedef {Object.<string, (string | (CoraliteTextNode | CoraliteElement)[])>} CoraliteModuleValues
+ * @typedef {Object.<string, (string | string[] | (CoraliteDirective | CoraliteAnyNode)[])>} CoraliteModuleValues
  */
 
 /**
@@ -141,3 +141,17 @@
 /**
  * @typedef {Array<Array<string, string>>} IgnoreByAttribute - An array of attribute names and values to ignore by element type.
  */
+
+/**
+ * @callback CoraliteAggregateFilter
+ * @param {Object.<string, string>} metadata - Aggregated HTML page metadata
+ */
+
+/**
+ * @typedef {Object} CoraliteAggregate – Configuration object for the aggregation process
+ * @property {string} path - The path to aggregate, relative to pages directory
+ * @property {CoraliteAggregateTemplate | string} template - Templates used to display the result
+ * @property {CoraliteAggregateFilter} [filter] - Callback to filter out unwanted elements from the aggregated content.
+ * @property {boolean} [recursive] - Whether to recursively search subdirectories
+ * @property {CoraliteTokenOptions} [tokens] - Token configuration options
+ */