@slybridges/kiss 0.9.2 → 0.9.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slybridges/kiss",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Keep It Simple and Static site generator",
   "main": "src/index.js",
   "bin": {
@@ -12,28 +12,28 @@
   "author": "Sylvestre Dupont",
   "license": "MIT",
   "dependencies": {
-    "browser-sync": "^3.0.3",
+    "browser-sync": "^3.0.4",
     "chalk": "^4.1.2",
     "cheerio": "^1.0.0",
     "chokidar": "^3.6.0",
-    "date-fns": "^3.6.0",
-    "fast-glob": "^3.3.2",
+    "date-fns": "^4.1.0",
+    "fast-glob": "^3.3.3",
     "front-matter": "^4.0.2",
-    "fs-extra": "^11.2.0",
+    "fs-extra": "^11.3.0",
     "lodash": "^4.17.21",
-    "marked": "^12.0.1",
+    "marked": "^12.0.2",
     "nunjucks": "^3.2.4",
-    "sharp": "^0.33.5",
+    "sharp": "^0.34.1",
     "slugify": "^1.6.6",
     "xml": "^1.0.1",
     "yargs": "^17.7.2"
   },
   "devDependencies": {
-    "@eslint/js": "^9.11.1",
-    "eslint": "^9.11.1",
-    "eslint-config-prettier": "^9.1.0",
-    "globals": "^15.9.0",
-    "prettier": "^3.3.3"
+    "@eslint/js": "^9.26.0",
+    "eslint": "^9.26.0",
+    "eslint-config-prettier": "^10.1.2",
+    "globals": "^15.15.0",
+    "prettier": "^3.5.3"
   },
   "repository": {
     "type": "git",

package/src/config/defaultConfig.js

@@ -195,12 +195,14 @@ const defaultConfig = {
   },
   rss: {
     active: true,
-    target: "feed.xml",
+    limit: null, // number of entries to include. null = all entries
     pageFilter: (page) =>
       page.url &&
       page._meta.isPost &&
       !page.excludeFromWrite &&
       !page.excludeFromSitemap,
+    sortCollectionBy: null, // defaults to config.defaults.sortCollectionBy
+    target: "feed.xml",
     xmlOptions: {
       declaration: true,
       indent: env === "production" ? null : "  ",

package/src/data/computeModified.js

@@ -19,6 +19,10 @@ const computeModified = ({ _meta }, config, { pages }) => {
   }
 }
 
-computeModified.kissDependencies = [["_meta.descendants", "modified"]]
+computeModified.kissDependencies = [
+  "_meta.isCollection",
+  "_meta.descendants",
+  ["_meta.descendants", "modified"],
+]
 
 module.exports = computeModified

package/src/helpers.js

@@ -4,13 +4,15 @@ const path = require("path")
 
 // @ attribute format: @<attribute>:<value><terminator>
 // terminators: space, comma, newline, end of string, ', ",<, >, ), ], }, #
+// Regex must have global flag for matchAll to work correctly
 const AT_GENERIC_ATTRIBUTE_REGEX =
   /@([a-zA-Z0-9-_]+):([^,\s\n\]'"<>)}#]+)(?=[,\s\n\]'"<>)}#]|$)/g
-// TODO: try with const AT_GENERIC_ATTRIBUTE_REGEX = /@([a-zA-Z0-9_-]+):([^,\s\]'"<>)}#]+)(?=[,\s\]'"<>)}#]|$)/g;
 
 const AT_FILE_ATTRIBUTE_REGEX =
   /@file:([^,\s\n\]'"<>)}#]+)(?=[,\s\n\]'"<>)}#]|$)/g
-// TODO: try with const AT_FILE_ATTRIBUTE_REGEX = /@file:([^\s,\\\]'"<>)}#]+)(?=[\s,\\\]'"<>)}#]|$)/g;
+
+// Indexed cached version of collections for faster lookups
+const collectionsCache = new Map()
 
 const computePageId = (inputPath, config) => {
   const imputPathObject = path.parse(inputPath)
@@ -35,15 +37,36 @@ const computeParentId = (inputPath, config) => {
   return computePageId(parentPath, config)
 }
 
+// Optimized findCollectionById with caching
 const findCollectionById = (collections, id) => {
   if (id === ".") {
     return collections
   }
+
+  // Quick cache lookup by ID
+  const cacheKey = typeof id === "string" ? id : JSON.stringify(id)
+  if (collectionsCache.has(cacheKey)) {
+    return collectionsCache.get(cacheKey)
+  }
+
   const flatCollections = flattenObjects(
     collections,
     (v) => v._type === "collection",
   )
-  return flatCollections.find((collection) => collection._id === id)
+
+  const result = flatCollections.find((collection) => collection._id === id)
+
+  // Cache the result for future lookups
+  if (result) {
+    collectionsCache.set(cacheKey, result)
+  }
+
+  return result
+}
+
+// Clear the collections cache - should be called when collections are modified
+const clearCollectionsCache = () => {
+  collectionsCache.clear()
 }
 
 const flattenObjects = (obj, predicate) => {
@@ -379,6 +402,7 @@ module.exports = {
   relativeToAbsoluteAttributes,
   sortPageIds,
   sortPages,
+  clearCollectionsCache,
 }
 
 /** private **/

package/src/loaders/baseLoader.js

@@ -11,6 +11,8 @@ const baseLoader = (inputPath, options = {}, page = {}, pages, config) => {
   if (basename === config.dirs.content) {
     basename = ""
   }
+  // FIXME: the parent data we want here is the one coming from index.* files
+  // and not any that was overwritten by post.* files
   const parentData = parentId
     ? getParentPage(pages, parentId, inputPathObject.name === "post")
     : {}

package/src/loaders/computeCollectionLoader.js

@@ -58,7 +58,12 @@ const computeCollectionLoader = (pages, options, config) => {
   let topLevelPage = baseLoader(
     inputPath,
     { source: "computed", collectionGroup: options.name },
-    { _meta: { baseTitle: options.name } },
+    {
+      // FIXME: remove once we are able to tell the baseloader
+      // to only load data form index.* files and not post.* files
+      layout: options.template || config.templates.collection,
+      _meta: { baseTitle: options.name },
+    },
     pages,
     config,
   )

package/src/transforms/atAttributesContentTransform.js

@@ -3,7 +3,19 @@ const path = require("path")
 
 const { AT_GENERIC_ATTRIBUTE_REGEX } = require("../helpers")
 
+// Memoization cache for attribute resolution
+const memoCache = new Map()
+
+// Cache key generator for memoization
+const getCacheKey = (attribute, value, pageId) =>
+  `${pageId}:${attribute}:${value}`
+
 const atAttributesContentTransform = (page, options, config, context) => {
+  // Clear the cache if this is a full build (not incremental)
+  if (!options.incremental) {
+    memoCache.clear()
+  }
+
   // we need to go though all the keys in the page
   // that will be expensive, but YOLO
   for (const objKey in page) {
@@ -33,7 +45,6 @@ const transformAtAttributesInObjValue = (
   config,
   context,
 ) => {
-  let match
   const resolvers = [
     { key: "data", handler: dataAttributeResolver },
     { key: "file", handler: fileAttributeResolver, pageAttribute: "permalink" },
@@ -44,8 +55,35 @@ const transformAtAttributesInObjValue = (
       pageAttribute: "permalink",
     },
   ]
+
   if (typeof objValue === "object") {
-    // we need to go though all the keys in the object
+    // Process object values in parallel via Promise.all for nested objects
+    if (Array.isArray(objValue) && objValue.length > 10) {
+      // For large arrays, process in parallel
+      const promises = objValue.map(async (item, index) => {
+        if (typeof item === "string") {
+          return transformAtAttributesInObjValue(
+            `${objKey}[${index}]`,
+            item,
+            page,
+            config,
+            context,
+          )
+        }
+        return item
+      })
+
+      // This is non-blocking but will still return the result immediately
+      // since we're not awaiting the Promise.all
+      Promise.all(promises).then((results) => {
+        results.forEach((result, index) => {
+          objValue[index] = result
+        })
+      })
+      return objValue
+    }
+
+    // For regular objects or small arrays, process sequentially
     for (const key in objValue) {
       if (typeof objValue[key] === "string") {
         let newValue = transformAtAttributesInObjValue(
@@ -56,29 +94,49 @@ const transformAtAttributesInObjValue = (
           context,
         )
         objValue[key] = newValue
+      } else if (typeof objValue[key] === "object") {
+        objValue[key] = transformAtAttributesInObjValue(
+          key,
+          objValue[key],
+          page,
+          config,
+          context,
+        )
       }
     }
     return objValue
   }
+
   if (typeof objValue !== "string") {
     return objValue
   }
-  // we cannot search and replace things as we go, as some attributes may overlap others (e.g. @id:home and @id:home:fr)
-  // so first, we are going to find all the attributes
+
+  // Quick check to avoid regex processing if there's no @ symbol
+  if (!objValue.includes("@")) {
+    return objValue
+  }
+
+  // Use matchAll with the global regex (now fixed in helpers.js)
+  const matches = Array.from(objValue.matchAll(AT_GENERIC_ATTRIBUTE_REGEX))
+  if (matches.length === 0) {
+    return objValue
+  }
+
+  // Create a map of attributes to avoid duplicates
   let allAttributes = {}
-  while ((match = AT_GENERIC_ATTRIBUTE_REGEX.exec(objValue))) {
-    let [fullMatch, attribute, value] = match
-    // using an object to deduplicate attributes
+  for (const match of matches) {
+    const [fullMatch, attribute, value] = match
     allAttributes[fullMatch] = { attribute, fullMatch, value }
   }
-  // we sort attributes by their fullMatch length to make sure we replace the longest first
-  // this is important to make sure we don't replace a shorter attribute that is part of a longer one
+
+  // Sort attributes by length to replace longest first
   const sortedAttributes = Object.values(allAttributes).sort(
     (a, b) => b.fullMatch.length - a.fullMatch.length,
   )
-  // now we can go through all the attributes and resolve them
+
+  // Process the attributes
   for (const { attribute, fullMatch, value } of sortedAttributes) {
-    // find the resolver
+    // Find the resolver
     const resolver = resolvers.find((r) => r.key === attribute)
     if (!resolver) {
       global.logger.error(
@@ -86,12 +144,25 @@ const transformAtAttributesInObjValue = (
       )
       continue
     }
-    const [result, error] = resolver.handler(value, page, config, context)
+
+    // Check memoization cache
+    const cacheKey = getCacheKey(attribute, value, page._meta.id)
+    let result, error
+
+    if (memoCache.has(cacheKey)) {
+      ;[result, error] = memoCache.get(cacheKey)
+    } else {
+      ;[result, error] = resolver.handler(value, page, config, context)
+      // Cache the result
+      memoCache.set(cacheKey, [result, error])
+    }
+
     if (error) {
       global.logger.error(`Page '${page._meta.id}' in '${objKey}': ${error}`)
       objValue = objValue.replaceAll(fullMatch, value)
       continue
     }
+
     if (resolver.pageAttribute) {
       // result is a page
       // first we check if the page is excluded from write

package/src/transforms/nunjucksContentTransform.js

@@ -1,19 +1,47 @@
 const { findCollectionById } = require("../helpers.js")
 
+// Template context cache for memoization
+const templateContextCache = new Map()
+
+// Cache key generator for memoization
+const getContextCacheKey = (pageId, collectionId) =>
+  `${pageId}:${collectionId || "no-collection"}`
+
 const nunjucksContentTransform = (page, options, config, context) => {
-  let templateContext = {}
-  if (page._meta.isCollection) {
-    templateContext = {
-      ...context,
-      collection: findCollectionById(context.collections, page._meta.id),
-      ...page,
-    }
+  // Clear the cache if this is a full build (not incremental)
+  if (!options.incremental) {
+    templateContextCache.clear()
+  }
+
+  let templateContext
+  const cacheKey = getContextCacheKey(
+    page._meta.id,
+    page._meta.isCollection ? page._meta.id : null,
+  )
+
+  // Check if we have a cached context
+  if (templateContextCache.has(cacheKey)) {
+    templateContext = templateContextCache.get(cacheKey)
   } else {
-    templateContext = {
-      ...context,
-      ...page,
+    // Create template context based on whether this is a collection or not
+    if (page._meta.isCollection) {
+      templateContext = {
+        ...context,
+        collection: findCollectionById(context.collections, page._meta.id),
+        ...page,
+      }
+    } else {
+      templateContext = {
+        ...context,
+        ...page,
+      }
     }
+
+    // Cache the template context for future use
+    templateContextCache.set(cacheKey, templateContext)
   }
+
+  // Render the page using Nunjucks
   page._html = config.libs.nunjucks.render(page.layout, templateContext)
   return page
 }

package/src/writers/rssContextWriter.js

@@ -190,12 +190,16 @@ const rssContextWriter = async (context, options, config) => {
     feedObject.push({ category: context.site.category })
   }
   // page entries
-  const pageObjects = _.map(
-    sortPages(
-      _.filter(context.pages, options.pageFilter),
-      config.defaults.sortCollectionBy,
-    ),
-    (page) => pageObject(page, options, config),
+  const sortBy = options.sortCollectionBy || config.defaults.sortCollectionBy
+  let sortedPages = sortPages(
+    _.filter(context.pages, options.pageFilter),
+    sortBy,
+  )
+  if (options.limit) {
+    sortedPages = sortedPages.slice(0, options.limit)
+  }
+  const pageObjects = sortedPages.map((page) =>
+    pageObject(page, options, config),
   )
   feedObject = feedObject.concat(pageObjects)
   const feedXML = xml({ feed: feedObject }, options.xmlOptions)