poops 1.1.0 → 1.2.1

package/lib/copy.js

@@ -8,9 +8,7 @@ import {
 } from './utils/helpers.js'
 import fs from 'node:fs'
 import path from 'node:path'
-import PrintStyle from './utils/print-style.js'
-
-const pstyle = new PrintStyle()
+import log from './utils/log.js'
 
 export default class Copy {
   constructor(config) {
@@ -26,7 +24,7 @@ export default class Copy {
 
     for (const copyEntry of this.config.copy) {
       if (!copyEntry.in || !copyEntry.out) {
-        console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset}[copy] ${pstyle.dim}Cannot copy. Missing 'in' or 'out' property in copy entry:${pstyle.reset} ${JSON.stringify(copyEntry)}`)
+        log({ tag: 'copy', error: true, text: `Cannot copy. Missing 'in' or 'out' property in copy entry: ${JSON.stringify(copyEntry)}` })
         continue
       }
 
@@ -53,7 +51,7 @@ export default class Copy {
               copyLastPath = inEntry
               copyPathCount++
             } else {
-              console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset}[copy] ${pstyle.dim}Cannot copy. Source path does not exist:${pstyle.reset} ${matchedPath}`)
+              log({ tag: 'copy', error: true, text: 'Cannot copy. Source path does not exist:', link: matchedPath })
             }
           }
           continue
@@ -65,9 +63,9 @@ export default class Copy {
           copyPathCount++
         } else {
           if (hasGlobMagic) {
-            console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset}[copy] ${pstyle.dim}No files matched glob pattern:${pstyle.reset} ${inEntry}`)
+            log({ tag: 'copy', error: true, text: 'No files matched glob pattern:', link: inEntry })
           } else {
-            console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset}[copy] ${pstyle.dim}Cannot copy. Source path does not exist:${pstyle.reset} ${inEntry}`)
+            log({ tag: 'copy', error: true, text: 'Cannot copy. Source path does not exist:', link: inEntry })
           }
         }
       }
@@ -76,11 +74,11 @@ export default class Copy {
     const copyEndTime = performance.now()
     if (copyPathCount === 0) return
     if (copyPathCount === 1) {
-      console.log(`${pstyle.green + pstyle.bold}[copy]${pstyle.reset} ${pstyle.dim}Copied${pstyle.reset} ${pstyle.italic + pstyle.underline}${copyLastPath}${pstyle.reset} ${pstyle.green}(${buildTime(copyStartTime, copyEndTime)})${pstyle.reset}`)
+      log({ tag: 'copy', text: 'Copied', link: copyLastPath, time: buildTime(copyStartTime, copyEndTime) })
       return
     }
 
-    console.log(`${pstyle.green + pstyle.bold}[copy]${pstyle.reset} ${pstyle.dim}Copied${pstyle.reset} ${copyPathCount} paths ${pstyle.green}(${buildTime(copyStartTime, copyEndTime)})${pstyle.reset}`)
+    log({ tag: 'copy', text: `Copied ${copyPathCount} paths`, time: buildTime(copyStartTime, copyEndTime) })
   }
 
   async unlink(file, copyPaths) {

package/lib/markup/collections.js

@@ -0,0 +1,247 @@
+import fs from 'node:fs'
+import { globSync } from 'glob'
+import path from 'node:path'
+import log from '../utils/log.js'
+import { mkDir } from '../utils/helpers.js'
+import { replaceOutExtensions, getRelativePathPrefix, getPageUrl, parseFrontMatter } from './helpers.js'
+
+export function getSingleCollectionData(markupInDir, collectionName) {
+  const collectionData = []
+  globSync(path.join(process.cwd(), markupInDir, collectionName, '**/*.+(html|njk|liquid|md)'), { ignore: ['**/index.+(html|njk|liquid|md)'] }).forEach((file) => {
+    let frontMatter = {}
+
+    try {
+      const frontMatterResult = parseFrontMatter(file)
+      frontMatter = frontMatterResult.frontMatter
+    } catch (err) {
+      log({ tag: 'error', text: 'Failed parsing front matter:', link: file })
+      console.error(err)
+    }
+
+    if (frontMatter.published === false) return
+
+    if (!frontMatter.date) {
+      frontMatter.date = fs.statSync(file).ctime.toISOString().slice(0, 16)
+    }
+    frontMatter.fileName = path.basename(file)
+    frontMatter.filePath = path.relative(process.cwd(), file)
+    frontMatter.collection = collectionName
+    frontMatter.url = path.join(collectionName, path.basename(frontMatter.filePath))
+
+    frontMatter.url = replaceOutExtensions(frontMatter.url)
+
+    if (!frontMatter.title) {
+      frontMatter.title = path.basename(frontMatter.filePath, path.extname(frontMatter.filePath))
+    }
+    collectionData.push(frontMatter)
+  })
+
+  return collectionData
+}
+
+export function collectionAutoDiscovery(markupInDir) {
+  const indexFiles = globSync(path.join(process.cwd(), markupInDir, '/**/index.+(html|njk|liquid|md)'))
+
+  const collectionData = {}
+
+  for (const indexFile of indexFiles) {
+    let frontMatter = {}
+
+    try {
+      const frontMatterResult = parseFrontMatter(indexFile)
+      frontMatter = frontMatterResult.frontMatter
+    } catch (err) {
+      log({ tag: 'error', text: 'Failed parsing front matter:', link: indexFile })
+      console.error(err)
+    }
+
+    if (!frontMatter.collection) continue
+
+    if (frontMatter.collection === true) {
+      frontMatter.collection = path.basename(path.dirname(indexFile))
+    }
+
+    const collectionName = frontMatter.collection.trim()
+
+    if (collectionName === '') continue
+
+    frontMatter.name = collectionName
+    const collection = buildCollectionObject(markupInDir, frontMatter)
+    if (!collection) continue
+    collectionData[collection.name] = collection
+  }
+
+  return collectionData
+}
+
+export function getCollectionDataBasedOnConfig(markupInDir, collectionConfig) {
+  if (!collectionConfig) return {}
+
+  const items = Array.isArray(collectionConfig)
+    ? collectionConfig
+    : [collectionConfig]
+
+  const collectionData = {}
+
+  for (let item of items) {
+    if (typeof item === 'string') item = { name: item }
+    if (!item || !item.name) continue
+    const collection = buildCollectionObject(markupInDir, item)
+    if (collection) collectionData[item.name] = collection
+  }
+
+  return collectionData
+}
+
+export function buildCollectionObject(markupInDir, collectionProtoObject) {
+  const collection = {
+    name: collectionProtoObject.name,
+    items: getSingleCollectionData(markupInDir, collectionProtoObject.name)
+  }
+
+  if (collection.items.length === 0) return null
+
+  if (collectionProtoObject.paginate && !isNaN(parseInt(collectionProtoObject.paginate))) {
+    collection.paginate = parseInt(collectionProtoObject.paginate)
+  }
+
+  if (collectionProtoObject.sort) {
+    collection.sort = collectionProtoObject.sort
+  }
+
+  if (typeof collection.sort === 'string') {
+    collection.sort = { by: collection.sort }
+  }
+
+  if (!collection.sort) {
+    collection.sort = { by: 'date' }
+  }
+
+  if (!collection.sort.by) {
+    collection.sort.by = 'date'
+  }
+
+  if (collection.sort.by === 'date') {
+    collection.sort.type = 'date'
+  } else {
+    collection.sort.type = 'alphabetical'
+  }
+
+  if (!collection.sort.order) {
+    collection.sort.order = collection.sort.type === 'date' ? 'desc' : 'asc'
+  }
+
+  collection.items.sort((a, b) => {
+    if (collection.sort.type === 'date') {
+      if (collection.sort.order === 'asc') {
+        return new Date(a[collection.sort.by]) - new Date(b[collection.sort.by])
+      }
+
+      return new Date(b[collection.sort.by]) - new Date(a[collection.sort.by])
+    } else {
+      const aVal = a[collection.sort.by]
+      const bVal = b[collection.sort.by]
+      if (aVal === bVal) return 0
+      if (collection.sort.order === 'asc') {
+        return aVal > bVal ? 1 : -1
+      }
+
+      return aVal < bVal ? 1 : -1
+    }
+  })
+
+  return collection
+}
+
+export function buildCollectionPaginationData(collectionData) {
+  if (!collectionData) return
+
+  for (const collectionName of Object.keys(collectionData)) {
+    const collection = collectionData[collectionName]
+
+    if (!collection.paginate) continue
+
+    collection.pages = []
+    let pageItems = []
+    for (const item of collection.items) {
+      if (pageItems.length === collection.paginate) {
+        collection.pages.push(pageItems)
+        pageItems = []
+      }
+      pageItems.push(item)
+    }
+    collection.pages.push(pageItems)
+
+    collection.totalPages = collection.pages.length
+  }
+}
+
+export function getCollectionIndexFile(markupInDir, collectionName) {
+  const indexFiles = globSync(path.join(process.cwd(), markupInDir, collectionName, 'index.+(html|njk|liquid|md)'))
+  if (indexFiles.length === 0) return null
+  return indexFiles[0]
+}
+
+export function generateCollectionPaginationPages(collectionData, markupInDir, markupOutDir, compileEntryFn) {
+  if (!collectionData) return []
+
+  const compilePromises = []
+
+  for (const collectionName of Object.keys(collectionData)) {
+    const collection = collectionData[collectionName]
+    const file = getCollectionIndexFile(markupInDir, collectionName)
+
+    if (!collection.totalPages || collection.totalPages === 0) {
+      collection.totalPages = 1
+      collection.pages = [collection.items]
+    }
+
+    for (let i = 0; i < collection.totalPages; i++) {
+      const pageNumber = i + 1
+      const pageUrl = pageNumber === 1 ? collection.name : `${collection.name}/${pageNumber}`
+      const nextPage = pageNumber === collection.totalPages ? null : pageNumber + 1
+      const nextPageUrl = pageNumber === collection.totalPages ? null : `${collection.name}/${pageNumber + 1}`
+      let prevPage = pageNumber === 1 ? null : pageNumber - 1
+      let prevPageUrl = pageNumber === 1 ? null : `${collection.name}/${pageNumber - 1}`
+      if (prevPage === 1) {
+        prevPageUrl = collection.name
+      }
+
+      // Snapshot per-page properties to avoid async mutation
+      const pageSnapshot = {
+        ...collection,
+        pageItems: collection.pages[i],
+        pageNumber,
+        pageUrl,
+        nextPage,
+        nextPageUrl,
+        prevPage,
+        prevPageUrl
+      }
+
+      const markupOut = path.join(process.cwd(), markupOutDir, pageUrl, 'index.html')
+      const fromPath = path.join(process.cwd(), markupOutDir)
+      const markupOutDirFull = path.dirname(markupOut)
+
+      mkDir(markupOutDirFull)
+
+      const context = {
+        ...collectionData,
+        [collectionName]: pageSnapshot,
+        relativePathPrefix: getRelativePathPrefix(markupOutDirFull, fromPath),
+        _url: getPageUrl(markupOut)
+      }
+
+      if (!file) {
+        continue
+      }
+
+      const compilePromise = compileEntryFn(file, context).then(({ result }) => {
+        fs.writeFileSync(markupOut, result)
+      })
+      compilePromises.push(compilePromise)
+    }
+  }
+
+  return compilePromises
+}

package/lib/markup/engines/liquid.js

@@ -0,0 +1,240 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { Liquid } from 'liquidjs'
+import { Marked } from 'marked'
+import { highlightRenderer, highlightCode } from '../highlight.js'
+import { discoverImageVariants, parseFrontMatter } from '../helpers.js'
+import { slugify } from 'book-of-spells'
+import dayjs from 'dayjs'
+
+const marked = new Marked({ renderer: highlightRenderer })
+
+export default class LiquidEngine {
+  constructor(templatesDir, includePaths) {
+    const roots = [templatesDir]
+    for (const inc of includePaths || []) {
+      roots.push(path.join(templatesDir, inc))
+    }
+    // Also add any _* directories as include roots
+    try {
+      const entries = fs.readdirSync(templatesDir, { withFileTypes: true })
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.startsWith('_')) {
+          roots.push(path.join(templatesDir, entry.name))
+        }
+      }
+    } catch { /* ignore */ }
+
+    this.engine = new Liquid({
+      root: roots,
+      extname: '.liquid',
+      cache: false,
+      dynamicPartials: true,
+      strictFilters: false,
+      strictVariables: false,
+      jsTruthy: true
+    })
+
+    this.globals = {}
+  }
+
+  get fileExtension() { return '.liquid' }
+  get indexableExtensions() { return new Set(['.html', '.md', '.liquid']) }
+  get markupExtensions() { return 'html|xml|rss|atom|json|liquid|md' }
+
+  registerFilters({ timeDateFormat, markupOut }) {
+    const engine = this.engine
+    engine.registerFilter('slugify', (str) => slugify(str))
+    engine.registerFilter('jsonify', (obj) => JSON.stringify(obj))
+    engine.registerFilter('markdown', (str) => marked.parse(str))
+    engine.registerFilter('date', (str, template) => {
+      const fmt = template || timeDateFormat
+      if (!fmt) return str
+      const date = !str || (typeof str === 'string' && str.trim() === '') ? new Date() : new Date(str)
+      return dayjs(date).format(fmt)
+    })
+    engine.registerFilter('concat', (arr, value) => {
+      if (!Array.isArray(arr)) return [value]
+      return arr.concat(value)
+    })
+    engine.registerFilter('push', (arr, value) => {
+      if (!Array.isArray(arr)) return [value]
+      arr.push(value)
+      return arr
+    })
+    engine.registerFilter('svg', (filePath) => {
+      const fullPath = path.resolve(process.cwd(), filePath)
+      if (!fs.existsSync(fullPath)) return ''
+      const content = fs.readFileSync(fullPath, 'utf-8').trim()
+      if (!/^(<\?xml[^?]*\?>\s*)?<svg[\s>]/i.test(content)) return ''
+      return content
+    })
+    engine.registerFilter('srcset', (imagePath) => {
+      const outputDir = path.join(process.cwd(), markupOut)
+      const { variants } = discoverImageVariants(imagePath, outputDir)
+      if (variants.length === 0) return ''
+      return variants.map(v => `${v.path} ${v.width}w`).join(', ')
+    })
+    engine.registerFilter('highlight', (code, lang) => {
+      const highlighted = highlightCode(code, lang)
+      const langClass = lang ? ` language-${lang}` : ''
+      return `<pre><code class="hljs${langClass}">${highlighted}</code></pre>`
+    })
+  }
+
+  registerTags(getOutputDir) {
+    registerGoogleFontsTag(this.engine)
+    registerImageTag(this.engine, getOutputDir)
+    registerHighlightTag(this.engine)
+  }
+
+  setGlobal(key, value) {
+    this.globals[key] = value
+  }
+
+  async render(templateName, context) {
+    let source
+    const frontMatterResult = parseFrontMatter(templateName)
+    source = frontMatterResult.content
+
+    if (path.extname(templateName) === '.md') {
+      source = marked.parse(source)
+    }
+
+    const frontMatter = context.page || {}
+    if (frontMatter.layout) {
+      source = `{% layout '${frontMatter.layout}${this.fileExtension}' %}{% block content %}${source}{% endblock %}`
+    }
+
+    return this.engine.parseAndRender(source, { ...this.globals, ...context }, {
+      globals: this.globals
+    })
+  }
+
+  async renderString(source, context) {
+    return this.engine.parseAndRender(source, { ...this.globals, ...context }, {
+      globals: this.globals
+    })
+  }
+}
+
+// --- Liquid Tags ---
+
+function registerGoogleFontsTag(engine) {
+  engine.registerTag('googleFonts', {
+    parse(tagToken) {
+      this.value = tagToken.args.trim()
+    },
+    * render(ctx) {
+      const fonts = yield this.liquid.evalValue(this.value, ctx)
+      if (!fonts || (Array.isArray(fonts) && fonts.length === 0)) return ''
+
+      const fontList = typeof fonts === 'string' ? [fonts] : fonts
+      const display = 'swap'
+
+      const families = fontList.map(font => {
+        if (typeof font === 'string') return `family=${font.replace(/\s+/g, '+')}`
+        const name = font.name || font.family || ''
+        const weights = font.weights || font.wght
+        let param = `family=${name.replace(/\s+/g, '+')}`
+        if (weights) {
+          const wList = Array.isArray(weights) ? weights : [weights]
+          param += `:wght@${wList.join(';')}`
+        }
+        if (font.ital) {
+          param = param.replace(':wght@', ':ital,wght@')
+          const wList = param.match(/@(.+)$/)[1].split(';')
+          const expanded = []
+          for (const w of wList) { expanded.push(`0,${w}`); expanded.push(`1,${w}`) }
+          param = param.replace(/@.+$/, `@${expanded.join(';')}`)
+        }
+        return param
+      })
+
+      const url = `https://fonts.googleapis.com/css2?${families.join('&')}&display=${display}`
+      return `<link rel="preconnect" href="https://fonts.googleapis.com">\n
+        <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>\n
+        <link href="${url}" rel="stylesheet">`
+    }
+  })
+}
+
+function registerImageTag(engine, getOutputDir) {
+  engine.registerTag('image', {
+    parse(tagToken) {
+      this.args = tagToken.args
+    },
+    * render(ctx) {
+      const argsStr = this.args.trim()
+      const parts = argsStr.split(',').map(s => s.trim())
+
+      let imagePath = parts[0]
+      if (imagePath.startsWith('"') || imagePath.startsWith("'")) {
+        imagePath = imagePath.slice(1, -1)
+      } else {
+        imagePath = yield ctx.get(imagePath.split('.'))
+      }
+
+      const kwargs = {}
+      for (let i = 1; i < parts.length; i++) {
+        const colonIdx = parts[i].indexOf(':')
+        if (colonIdx === -1) continue
+        const key = parts[i].slice(0, colonIdx).trim()
+        let val = parts[i].slice(colonIdx + 1).trim()
+        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+          val = val.slice(1, -1)
+        }
+        kwargs[key] = val
+      }
+
+      const prefix = (yield ctx.get(['relativePathPrefix'])) || ''
+      const alt = kwargs.alt || ''
+      const loading = kwargs.loading || 'lazy'
+      const isSvg = imagePath.endsWith('.svg')
+      const attrs = [`alt="${alt}"`]
+
+      if (isSvg) {
+        attrs.unshift(`src="${prefix}${imagePath}"`)
+      } else {
+        const outputDir = getOutputDir()
+        const { src, variants } = discoverImageVariants(imagePath, outputDir)
+        const sizes = kwargs.sizes || '100vw'
+        attrs.unshift(`src="${prefix}${src}"`)
+        if (variants.length > 0) {
+          const srcsetVal = variants.map(v => `${prefix}${v.path} ${v.width}w`).join(', ')
+          attrs.push(`srcset="${srcsetVal}"`)
+          attrs.push(`sizes="${sizes}"`)
+        }
+      }
+
+      attrs.push(`loading="${loading}"`)
+      const skip = new Set(['alt', 'sizes', 'loading'])
+      for (const [key, val] of Object.entries(kwargs)) {
+        if (skip.has(key)) continue
+        attrs.push(`${key}="${val}"`)
+      }
+      return `<img ${attrs.join(' ')}>`
+    }
+  })
+}
+
+function registerHighlightTag(engine) {
+  engine.registerTag('highlight', {
+    parse(tagToken, remainTokens) {
+      this.lang = tagToken.args.trim()
+      this.templates = []
+      const stream = this.liquid.parser.parseStream(remainTokens)
+        .on('tag:endhighlight', () => stream.stop())
+        .on('template', (tpl) => this.templates.push(tpl))
+        .on('end', () => { throw new Error('tag {% highlight %} not closed with {% endhighlight %}') })
+      stream.start()
+    },
+    * render(ctx) {
+      const code = yield this.liquid.renderer.renderTemplates(this.templates, ctx)
+      const lang = this.lang
+      const highlighted = highlightCode(code, lang)
+      const langClass = lang ? ` language-${lang}` : ''
+      return `<pre><code class="hljs${langClass}">${highlighted}</code></pre>`
+    }
+  })
+}