@slybridges/kiss 0.5.5 → 0.6.2

package/README.md

@@ -42,7 +42,7 @@ Concept is being tuned until reaching v1. Things might break. Use at your own ri
 
 ## Requirements
 
-Node 10 or above.
+Node 12 or above.
 
 ## Quick start
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slybridges/kiss",
-  "version": "0.5.5",
+  "version": "0.6.2",
   "description": "Keep It Simple and Static site generator",
   "main": "src/index.js",
   "bin": {
@@ -12,24 +12,24 @@
   "author": "Sylvestre Dupont",
   "license": "MIT",
   "dependencies": {
-    "browser-sync": "^2.27.5",
+    "browser-sync": "^2.27.7",
     "chalk": "^4.1.2",
     "cheerio": "^1.0.0-rc.10",
-    "chokidar": "^3.5.2",
-    "date-fns": "^2.23.0",
-    "fast-glob": "^3.2.7",
+    "chokidar": "^3.5.3",
+    "date-fns": "^2.28.0",
+    "fast-glob": "^3.2.11",
     "front-matter": "^4.0.2",
     "fs-extra": "^10.0.0",
     "lodash": "^4.17.21",
-    "marked": "^3.0.0",
+    "marked": "^4.0.12",
     "nunjucks": "^3.2.3",
-    "sharp": "^0.28.3",
-    "slugify": "^1.6.0",
+    "sharp": "^0.30.1",
+    "slugify": "^1.6.5",
     "xml": "^1.0.1",
-    "yargs": "^17.1.1"
+    "yargs": "^17.3.1"
   },
   "devDependencies": {
-    "eslint": "^7.32.0"
+    "eslint": "^8.9.0"
   },
   "repository": {
     "type": "git",

package/src/build.js

@@ -152,7 +152,14 @@ const computeDataViews = (context, config) => {
     const message =
       description || `Computing '${attribute}' data view using ${handler.name}`
     global.logger.info(message)
-    _.set(context, attribute, handler(context, options, config))
+    try {
+      _.set(context, attribute, handler(context, options, config))
+    } catch (err) {
+      global.logger.error(
+        `[${handler.name}] Error during computing data view for '${attribute}'\n`,
+        err.stack
+      )
+    }
   })
   return context
 }
@@ -224,7 +231,14 @@ const computeAllPagesData = (context, config) => {
   while (round === 1 || pendingTotal > 0) {
     pendingTotal = 0
     _.forEach(context.pages, (page, key) => {
-      computed = computePageData(page, config, context)
+      try {
+        computed = computePageData(page, config, context)
+      } catch (err) {
+        global.logger.error(
+          `[computePageData] Error during computing page data for page id '${page._meta.id}'\n`,
+          err.stack
+        )
+      }
       context.pages[key] = computed.data
       pendingTotal += computed.pendingCount
     })
@@ -326,9 +340,12 @@ const loadContent = async (config, context) => {
     config.loaders
       .filter((loader) => !loader.source || loader.source === "file")
       .map(async ({ handler, namespace, ...loaderOptions }) => {
-        const { description, match, matchOptions = {}, ...options } = namespace
-          ? _.get(config, namespace, {})
-          : loaderOptions
+        const {
+          description,
+          match,
+          matchOptions = {},
+          ...options
+        } = namespace ? _.get(config, namespace, {}) : loaderOptions
         if ("active" in options && !options.active) {
           global.logger.log(`- [${handler.name}]: loader not active. Skipping.`)
           return

package/src/data/computeImage.js

@@ -1,6 +1,5 @@
 const cheerio = require("cheerio")
-const path = require("path")
-const { isValidURL } = require("../helpers")
+const { getAbsolutePath } = require("../helpers")
 
 const computeImage = (
   page,
@@ -8,47 +7,67 @@ const computeImage = (
   { pages, site },
   { setDefaultImage = true } = {}
 ) => {
+  if (typeof page.cover === "string") {
+    // there is a manually set cover image
+    return getImagePermalink(
+      page.cover,
+      page.permalink,
+      setDefaultImage,
+      site.image
+    )
+  }
+  // needed as computeImage is called recursively
   if (typeof page.image === "string") {
-    // needed as computeImage is called recursively
-    return page.image
+    return getImagePermalink(
+      page.image,
+      page.permalink,
+      setDefaultImage,
+      site.image
+    )
   }
   if (!page.content) {
-    // check if there are descendants
+    // Search in descendants
     if (!page._meta.descendants || page._meta.descendants.length === 0) {
       return setDefaultImage ? site.image : null
     }
     // return the first image it finds
-    let id = page._meta.descendants.find((id) =>
-      computeImage(
-        pages[id],
-        config,
-        { pages, site },
-        { setDefaultImage: false }
-      )
-    )
-    if (id) {
-      return computeImage(
-        pages[id],
+    for (const id of page._meta.descendants) {
+      const descendant = pages[id]
+      let image = computeImage(
+        descendant,
         config,
         { pages, site },
         { setDefaultImage: false }
       )
+      if (image) {
+        // found an image in descendants: break for loop
+        // no need to call getImagePermalink() here, it would have been called in recursive call
+        return image
+      }
     }
+    // no result anywhere
     return setDefaultImage ? site.image : null
   }
   // searches for an img tag in content
   const $ = cheerio.load(page.content)
   const src = $("img").first().attr("src")
-  if (!src) {
-    return setDefaultImage ? site.image : null
-  }
-  if (isValidURL(src)) {
-    return src
-  }
-  // return the image, as an absolute path
-  return path.isAbsolute(src) ? src : path.join(page.permalink, src)
+  return getImagePermalink(src, page.permalink, setDefaultImage, site.image)
 }
 
 computeImage.kissDependencies = ["content", "permalink", "_meta.descendants"]
 
 module.exports = computeImage
+
+/** private */
+
+const getImagePermalink = (
+  src,
+  pagePermalink,
+  setDefaultImage,
+  defaultImage
+) => {
+  if (!src) {
+    return setDefaultImage ? defaultImage : null
+  }
+  return getAbsolutePath(src, pagePermalink, { throwIfInvalid: true })
+}

package/src/helpers.js

@@ -29,10 +29,16 @@ const getAbsolutePath = (pathname, basePath, options = {}) => {
       `[getAbsolutePath]: expected path to be a string, got '${typeof pathname}'.`
     )
   }
-  if (isValidURL(pathname) || path.isAbsolute(pathname)) {
-    // don't change urls or absolute paths
+  if (isValidURL(pathname)) {
+    // don't change urls
     return pathname
   }
+  if (path.isAbsolute(pathname)) {
+    // prefix absolute paths with absoluteBase, if any
+    return options.absoluteBase
+      ? path.join(options.absoluteBase, pathname)
+      : pathname
+  }
   if (!isValidPath(pathname)) {
     if (options.throwIfInvalid) {
       throw new Error(`[getAbsolutePath]: Path '${pathname}' is invalid`)
@@ -87,6 +93,25 @@ const getDescendantPages = (
   return descendants
 }
 
+/** Computes the input path based on the permalink by checking if the parent
+ *  had a permalink different than their input path */
+const getInputPath = (permalink, pages, baseContentPath) => {
+  const pathPbject = path.parse(permalink)
+  // search if a have a parent corresponding to this permalink
+  const parent = _.find(
+    pages,
+    (page) => page.permalink === pathPbject.dir + "/"
+  )
+  if (!parent) {
+    // no result: assume inputPath same as permalink
+    return path.join(baseContentPath, permalink)
+  }
+  return path.join(
+    path.dirname(parent._meta.inputPath), // inputPath of parent's dir
+    pathPbject.base // filename
+  )
+}
+
 const getLocale = (context, sep = "-") => {
   const locale = _.get(context, "site.locale")
   if (!locale) {
@@ -197,6 +222,7 @@ module.exports = {
   getAbsoluteURL,
   getChildrenPages,
   getDescendantPages,
+  getInputPath,
   getLocale,
   getPageId,
   getParentId,

package/src/libs/loadMarked.js

@@ -1,4 +1,4 @@
-const marked = require("marked")
+const { marked } = require("marked")
 
 const loadMarked = (_, config) => {
   config.libs.marked = marked

package/src/libs/loadNunjucksFilters.js

@@ -1,6 +1,7 @@
 const parseISO = require("date-fns/parseISO")
 const _formatDate = require("date-fns/format")
 const _formatDateISO = require("date-fns/formatISO")
+const locales = require("date-fns/locale")
 
 const allFilters = (_, config) => {
   if (!config.libs.nunjucks) {
@@ -23,7 +24,15 @@ const formatDate = (_, config) => {
       return ""
     }
     let date = typeof str === "string" ? parseISO(str) : str
-    return _formatDate(date, format || config.defaults.dateFormat)
+    const fullLocale = config.context.site.locale.join("")
+    const shortLocale = config.context.site.locale[0]
+    let locale = locales["en"]
+    if (locales[fullLocale]) {
+      locale = locales[fullLocale]
+    } else if (locales[shortLocale]) {
+      locale = locales[shortLocale]
+    }
+    return _formatDate(date, format || config.defaults.dateFormat, { locale })
   })
   return config
 }

package/src/loaders/computeCollectionLoader.js

@@ -12,10 +12,7 @@ const computeCollectionLoader = (pages, options, config) => {
   options.pageData = options.pageData || pages["."]
   options.filter = options.filter || ((page) => !!page.content) //no access to isPost yet (we're pre-cascade)
   options.name = options.name || options.groupBy
-  let baseLink = path.join(
-    "/",
-    options.baseLink || libs.slugify(options.groupBy)
-  )
+  let baseLink = path.join("/", options.baseLink || libs.slugify(options.name))
   if (options.groupByType === "array") {
     if (typeof options.groupBy !== "string") {
       throw new Error(

package/src/transforms/imageContextTransform.js

@@ -3,7 +3,12 @@ const cheerio = require("cheerio")
 const path = require("path")
 const sharp = require("sharp")
 
-const { getAbsolutePath, isValidURL } = require("../helpers")
+const {
+  getAbsolutePath,
+  getInputPath,
+  getPageId,
+  isValidURL,
+} = require("../helpers")
 
 const META_SELECTORS = [
   "meta[property='og:image']",
@@ -25,17 +30,25 @@ const imageContextTransform = async (context, options, config) => {
           `Image '${src}' on page '${page._meta.outputPath}' has no 'alt' attribute.`
         )
       }
-      let imgPath = getAbsolutePath(src, page.permalink, {
+      const imgPermalink = getAbsolutePath(src, page.permalink, {
         throwIfInvalid: true,
       })
+      const imgInputPath = getInputPath(
+        imgPermalink,
+        context.pages,
+        config.dirs.content
+      )
+      const imgId = getPageId(imgInputPath, config)
       const imageDetails = await getImageDetails(
-        imgPath,
+        imgInputPath,
+        imgPermalink,
+        imgId,
         id,
         context,
         options,
         config
       )
-      context.pages[imgPath] = imageDetails
+      context.pages[imgId] = imageDetails
       if (!imageDetails._meta.is404) {
         $(img).replaceWith(getImageTag($(img).clone(), imageDetails))
         context.pages[id]._html = $.html()
@@ -55,15 +68,23 @@ const imageContextTransform = async (context, options, config) => {
         return
       }
       const url = new URL(content)
-      const imgPath = decodeURI(url.pathname)
+      const imgPermalink = decodeURI(url.pathname)
+      const imgInputPath = getInputPath(
+        imgPermalink,
+        context.pages,
+        config.dirs.content
+      )
+      const imgId = getPageId(imgInputPath, config)
       const imageDetails = await getImageDetails(
-        imgPath,
+        imgInputPath,
+        imgPermalink,
+        imgId,
         id,
         context,
         options,
         config
       )
-      context.pages[imgPath] = imageDetails
+      context.pages[imgId] = imageDetails
       if (!imageDetails._meta.is404) {
         const newPathname = getDefaultDerivative(imageDetails).permalink
         $(selector).attr("content", new URL(newPathname, url.origin))
@@ -147,27 +168,37 @@ const getDerivatives = (page, options, config) => {
   return derivatives
 }
 
-const getImageDetails = async (imgPath, sourceId, context, options, config) => {
+const getImageDetails = async (
+  inputPath,
+  permalink,
+  id,
+  sourceId,
+  context,
+  options,
+  config
+) => {
   let details = {}
-  if (!context.pages[imgPath]) {
-    global.logger.log(`- [imageContextTransform] image found: '${imgPath}'`)
+  if (!context.pages[id]) {
+    global.logger.log(
+      `- [imageContextTransform] new image found: '${inputPath}'`
+    )
     details = {
       blur: options.blur,
       defaultWidth: options.defaultWidth || options.widths[0],
       defaultFormat: options.defaultFormat || options.formats[0],
       derivatives: [],
       formats: options.formats,
-      permalink: imgPath, // original permalink
-      permalinkDir: path.dirname(imgPath),
+      permalink,
+      permalinkDir: path.dirname(permalink),
       sizes: options.sizes || [],
       sources: [],
-      _meta: await getImageMetadata(imgPath, options, config),
+      _meta: await getImageMetadata(inputPath, permalink, id, options, config),
     }
     if (!details._meta.is404) {
       details.derivatives = getDerivatives(details, options, config)
     }
   } else {
-    details = context.pages[imgPath]
+    details = context.pages[id]
   }
   if (details.sources.indexOf(sourceId) === -1) {
     details.sources.push(sourceId)
@@ -202,22 +233,21 @@ const getImageTag = (imgNode, page) => {
   return picture
 }
 
-const getImageMetadata = async (imgPath, options, config) => {
-  const { ext, name } = path.parse(imgPath)
-  const srcPath = path.join(config.dirs.content, imgPath)
-  const outputPath = path.join(config.dirs.public, imgPath)
+const getImageMetadata = async (inputPath, permalink, id, options, config) => {
+  const { ext, name } = path.parse(inputPath)
+  const outputPath = path.join(config.dirs.public, permalink)
   let meta = {
     basename: name + ext,
     ext,
-    id: imgPath,
-    inputPath: srcPath,
-    isURL: isValidURL(imgPath),
+    id,
+    inputPath,
+    isURL: isValidURL(permalink),
     name,
     outputPath, // output path of original file
     outputType: "IMAGE",
   }
   try {
-    const image = sharp(srcPath)
+    const image = sharp(inputPath)
     const { format, width, height } = await image.metadata()
     meta = {
       ...meta,
@@ -230,7 +260,7 @@ const getImageMetadata = async (imgPath, options, config) => {
     }
   } catch (err) {
     global.logger.error(
-      `[getImageMetadata] Error getting image metadata for ${srcPath}\n`,
+      `[getImageMetadata] Error getting image metadata for ${inputPath}\n`,
       err.stack
     )
     meta.is404 = true

package/src/views/computeIterableCollectionDataView.js

@@ -0,0 +1,45 @@
+const _ = require("lodash")
+
+const computeIterableCollectionDataView = (context, options = {}, config) => {
+  if (!options.name) {
+    throw new Error(
+      "computeIterableCollectionDataView needs a collection 'name' option."
+    )
+  }
+  if (!context.collections) {
+    throw new Error(
+      "computeIterableCollectionDataView: collections not found. Were they computed?"
+    )
+  }
+  const collection = context.collections[options.name]
+  if (!collection) {
+    throw new Error(
+      `computeIterableCollectionDataView: no collection with name '${options.name}'`
+    )
+  }
+  return getCollectionObject(collection, "allPosts", context, config)
+}
+
+module.exports = computeIterableCollectionDataView
+
+/** Private **/
+
+const getCollectionObject = (collection, name, context, config) => {
+  const page = context.pages[collection._id]
+  if (!page) {
+    throw new Error(
+      `computeIterableCollectionDataView: couldn't find page with id'${collection._id}'`
+    )
+  }
+  const childrenCollection = _.pickBy(collection, (entry) =>
+    _.isPlainObject(entry)
+  )
+  return {
+    name: _.startCase(name),
+    entry: page,
+    allPosts: collection.allPosts,
+    children: _.map(childrenCollection, (child, childName) =>
+      getCollectionObject(child, childName, context, config)
+    ),
+  }
+}

package/src/views/index.js

@@ -1,9 +1,11 @@
 const computeCategoriesDataView = require("./computeCategoriesDataView")
 const computeCollectionDataView = require("./computeCollectionDataView")
+const computeIterableCollectionDataView = require("./computeIterableCollectionDataView")
 const computeSiteLastUpdatedDataView = require("./computeSiteLastUpdatedDataView")
 
 module.exports = {
   computeCategoriesDataView,
   computeCollectionDataView,
+  computeIterableCollectionDataView,
   computeSiteLastUpdatedDataView,
 }