poops 1.1.0 → 1.2.0

package/lib/markups.js

@@ -1,133 +1,80 @@
-import { pathExists, pathIsDirectory, readDataFile, deleteDirectory, mkDir, parseFrontMatter, clearFrontMatterCache } from './utils/helpers.js'
+import { pathExists, pathIsDirectory, readDataFile, mkDir, buildTime } from './utils/helpers.js'
+import { replaceOutExtensions, getRelativePathPrefix, getPageUrl, getPageUrlRelativeToOutput, parseFrontMatter, clearFrontMatterCache } from './markup/helpers.js'
+import { collectionAutoDiscovery, getCollectionDataBasedOnConfig, buildCollectionPaginationData, generateCollectionPaginationPages } from './markup/collections.js'
+import { generateIndexFiles } from './markup/indexer.js'
+import NunjucksEngine from './markup/engines/nunjucks.js'
+import LiquidEngine from './markup/engines/liquid.js'
 import fs from 'node:fs'
 import { globSync } from 'glob'
-import { parse as parseMarkdown } from 'marked'
-import moment from 'moment'
-import nunjucks from 'nunjucks'
 import path from 'node:path'
-import PrintStyle from './utils/print-style.js'
-import yaml from 'yaml'
+import log from './utils/log.js'
 
-const pstyle = new PrintStyle()
-
-class RelativeLoader extends nunjucks.Loader {
-  constructor(templatesDir, includePaths) {
-    super()
-    this.templatesDir = templatesDir
-    this.includePaths = includePaths || []
-    this.includePaths.push('_*') // XXX: It is better to define templates and layouts directories in the config file? then all together include paths?
-  }
-
-  getSource(name) {
-    let fullPath = name
-    if (!fs.existsSync(name)) {
-      let pattern = `**/${name}`
-      if (this.includePaths) {
-        pattern = `{${this.includePaths.join(',')}}/${pattern}`
-      }
-      fullPath = globSync(path.join(this.templatesDir, pattern))[0]
-    }
-    if (!fs.existsSync(fullPath)) {
-      console.log(`${pstyle.cyanBright + pstyle.bold}[markup]${pstyle.reset} ${pstyle.redBright + pstyle.bold}[error]${pstyle.reset}${pstyle.dim} Template not found:${pstyle.reset} ${pstyle.italic + pstyle.underline}${name}${pstyle.reset}`)
-      // throw new Error(`Template not found: ${name}`)
-      return { src: '', path: fullPath, noCache: true }
-    }
-
-    let source = ''
-    let frontMatter = {}
-
-    try {
-      const frontMatterResult = parseFrontMatter(fullPath)
-      frontMatter = frontMatterResult.frontMatter
-      source = frontMatterResult.content
-    } catch (err) {
-      console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset}${pstyle.dim} Failed parsing front matter:${pstyle.reset} ${pstyle.italic + pstyle.underline}${fullPath}${pstyle.reset}`)
-      console.log(err)
-    }
-
-    if (path.extname(fullPath) === '.md') {
-      source = parseMarkdown(source)
-    }
-
-    if (frontMatter.layout) {
-      source = `{% extends '${frontMatter.layout}.html' %}\n{% block content %}\n${source}\n{% endblock %}`
-    }
-
-    return { src: source, path: fullPath, noCache: true }
-  }
-
-  resolve(from, to) {
-    return path.resolve(path.dirname(from), to)
-  }
+const ENGINES = {
+  nunjucks: NunjucksEngine,
+  liquid: LiquidEngine
 }
 
 export default class Markups {
   constructor(config) {
     this.config = config
-    if (!this.config.markup || !this.config.markup.in) return
-    if (!this.config.markup.options) this.config.markup.options = {}
+    const moduleConfig = this.config.markup
+
+    if (!moduleConfig || !moduleConfig.in) return
+    if (!moduleConfig.options) moduleConfig.options = {}
+
+    // Determine engine
+    const engineName = moduleConfig.engine || moduleConfig.options.engine || 'nunjucks'
+    this.logTag = 'markup'
+
+    // Normalize config
+    this.markupIn = moduleConfig.in
+    this.markupOut = moduleConfig.out || process.cwd()
+    this.siteData = moduleConfig.site || moduleConfig.options.site || {}
+    this.timeDateFormat = moduleConfig.options.timeDateFormat || moduleConfig.timeDateFormat
+    this.collectionsConfig = moduleConfig.options.collections || moduleConfig.collections
+    this.includePaths = moduleConfig.includePaths || moduleConfig.options.includePaths || []
+    this.searchIndexConfig = moduleConfig.options.searchIndex || moduleConfig.searchIndex
+    this.sitemapConfig = moduleConfig.options.sitemap || moduleConfig.sitemap
     this.dataFiles = []
-    this.includePaths = this.config.markup.includePaths || this.config.markup.options.includePaths || []
-
-    const options = {
-      autoescape: false,
-      watch: false,
-      noCache: true
-    }
 
-    if (this.config.markup.autoescape) {
-      options.autoescape = this.config.markup.autoescape || this.config.markup.options.autoescape
+    // Instantiate engine
+    const EngineClass = ENGINES[engineName]
+    if (!EngineClass) {
+      log({ tag: 'error', text: `Unknown markup engine: ${engineName}` })
+      return
     }
 
-    this.nunjucksEnv = new nunjucks.Environment(new RelativeLoader(path.join(process.cwd(), this.config.markup.in), this.includePaths), options)
-
-    // Add custom filters
-    this.nunjucksEnv.addFilter('slugify', str => {
-      return str.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-')
+    const templatesDir = path.join(process.cwd(), this.markupIn)
+    this.engine = new EngineClass(templatesDir, this.includePaths, {
+      autoescape: moduleConfig.autoescape || moduleConfig.options.autoescape || false
     })
 
-    this.nunjucksEnv.addFilter('jsonify', obj => {
-      return JSON.stringify(obj)
-    })
-
-    this.nunjucksEnv.addFilter('markdown', str => {
-      return parseMarkdown(str)
-    })
-
-    this.nunjucksEnv.addFilter('date', (str, template) => {
-      if (!template) template = this.config.markup.options.timeDateFormat || this.config.markup.timeDateFormat
-      if (!template) return str
-      const date = !str || str.trim() === '' ? new Date() : new Date(str)
-      return moment(date).format(template)
-    })
+    this.engine.registerFilters({ timeDateFormat: this.timeDateFormat, markupOut: this.markupOut })
+    this.engine.registerTags(() => path.join(process.cwd(), this.markupOut))
 
     // Load global variables
-
     const pkgPath = path.join(process.cwd(), 'package.json')
-
     if (fs.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
-      this.nunjucksEnv.addGlobal('package', pkg)
+      this.engine.setGlobal('package', JSON.parse(fs.readFileSync(pkgPath, 'utf-8')))
     }
 
-    const siteData = this.config.markup.site || this.config.markup.options.site || {}
-    this.nunjucksEnv.addGlobal('site', siteData)
+    this.engine.setGlobal('site', this.siteData)
 
     if (this.config.livereload_port) {
-      this.nunjucksEnv.addGlobal('livereload_port', this.config.livereload_port)
+      this.engine.setGlobal('livereload_port', this.config.livereload_port)
     }
 
-    if (this.config.ssgData) {
-      for (const [name, html] of Object.entries(this.config.ssgData)) {
-        this.nunjucksEnv.addGlobal(name, html)
+    if (this.config.reactorData) {
+      for (const [name, html] of Object.entries(this.config.reactorData)) {
+        this.engine.setGlobal(name, html)
       }
     }
 
-    const data = this.config.markup.data || this.config.markup.options.data
+    const data = moduleConfig.data || moduleConfig.options.data
     this.loadDataFiles(data)
 
-    if (!this.config.markup.out) {
-      this.config.markup.out = process.cwd()
+    if (!moduleConfig.out) {
+      moduleConfig.out = this.markupOut
     }
   }
 
@@ -139,30 +86,37 @@ export default class Markups {
       files = [files]
     }
 
-    const promises = []
-
-    // TODO: GLOB all files if it's a directory path
+    const dataDir = pathIsDirectory(this.markupIn) ? this.markupIn : path.dirname(this.markupIn)
+    const resolved = []
+    for (const file of files) {
+      const fullPath = path.join(process.cwd(), dataDir, file)
+      if (pathIsDirectory(fullPath)) {
+        const dirFiles = globSync(path.join(fullPath, '**/*.+(json|yml|yaml)'))
+        for (const f of dirFiles) {
+          resolved.push(path.relative(path.join(process.cwd(), dataDir), f))
+        }
+      } else {
+        resolved.push(file)
+      }
+    }
 
-    if (!this.dataFiles.length) this.dataFiles = files
+    if (!this.dataFiles.length) this.dataFiles = resolved
 
-    for (const dataFile of files) {
+    for (const dataFile of resolved) {
       try {
-        const dataDir = pathIsDirectory(this.config.markup.in) ? this.config.markup.in : path.dirname(this.config.markup.in)
         const data = readDataFile(path.join(process.cwd(), dataDir, dataFile))
         const globalKeyName = path.basename(dataFile, path.extname(dataFile)).replace(/[.\-\s]/g, '_')
-
-        promises.push(this.nunjucksEnv.addGlobal(globalKeyName, data))
+        this.engine.setGlobal(globalKeyName, data)
       } catch (err) {
-        console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset}${pstyle.dim} Data file not found:${pstyle.reset} ${pstyle.italic + pstyle.underline}${dataFile}${pstyle.reset}`)
+        log({ tag: 'error', text: 'Data file not found:', link: dataFile })
         continue
       }
     }
-
-    return Promise.all(promises)
   }
 
   reloadDataFiles() {
-    return this.loadDataFiles(this.dataFiles)
+    this.loadDataFiles(this.dataFiles)
+    return Promise.resolve()
   }
 
   generateMarkupGlobPattern(excludes) {
@@ -176,224 +130,13 @@ export default class Markups {
       markupDefaultExcludes.push(...this.config.includePaths)
     }
 
-    markupDefaultExcludes.push('_*') // Ignore directories starting with underscore
-
-    markupDefaultExcludes = [...new Set(markupDefaultExcludes)] // Remove duplicates
-
-    return `!(${markupDefaultExcludes.join('|')})/**/*.+(html|xml|rss|atom|json|njk|md)`
-  }
-
-  getFrontMatter(file, fileName) {
-    const source = fileName ? file : fs.readFileSync(file, 'utf-8')
-    if (!fileName) fileName = file
-
-    const match = source.match(/^\s*---\s*([\s\S]*?)---\s*/) // Front matter match
-    let frontMatter = {}
-
-    if (match) {
-      try {
-        frontMatter = yaml.parse(match[1]) // Pass front matter to the template
-      } catch (err) {
-        console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset}${pstyle.dim} Failed parsing front matter:${pstyle.reset} ${pstyle.italic + pstyle.underline}${fileName}${pstyle.reset}`)
-        console.log(err)
-      }
-    }
-
-    return frontMatter
-  }
-
-  getSingleCollectionData(collectionName) {
-    const collectionData = []
-    globSync(path.join(process.cwd(), this.config.markup.in, collectionName, '**/*.+(html|njk|md)'), { ignore: ['**/index.+(html|njk|md)'] }).forEach((file) => {
-      let frontMatter = {}
-
-      try {
-        const frontMatterResult = parseFrontMatter(file)
-        frontMatter = frontMatterResult.frontMatter
-      } catch (err) {
-        console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset}${pstyle.dim} Failed parsing front matter:${pstyle.reset} ${pstyle.italic + pstyle.underline}${file}${pstyle.reset}`)
-        console.log(err)
-      }
-
-      if (frontMatter.published === false) return // Skip unpublished items
-
-      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 = this.replaceOutExtensions(frontMatter.url)
-
-      if (!frontMatter.title) {
-        frontMatter.title = path.basename(frontMatter.filePath, path.extname(frontMatter.filePath))
-      }
-      collectionData.push(frontMatter)
-    })
-
-    return collectionData
-  }
-
-  collectionAutoDiscovery() {
-    const indexFiles = globSync(path.join(process.cwd(), this.config.markup.in, '/**/index.+(html|njk|md)'))
-
-    const collectionData = {}
-
-    for (const indexFile of indexFiles) {
-      let frontMatter = {}
-
-      try {
-        const frontMatterResult = parseFrontMatter(indexFile)
-        frontMatter = frontMatterResult.frontMatter
-      } catch (err) {
-        console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset}${pstyle.dim} Failed parsing front matter:${pstyle.reset} ${pstyle.italic + pstyle.underline}${indexFile}${pstyle.reset}`)
-        console.log(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 = this.buildCollectionObject(frontMatter)
-      if (!collection) continue
-      collectionData[collection.name] = collection
-    }
-
-    return collectionData
-  }
-
-  getCollectionDataBasedOnConfig(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 = this.buildCollectionObject(item)
-      if (collection) collectionData[item.name] = collection
-    }
-
-    return collectionData
-  }
-
-  buildCollectionObject(collectionProtoObject) {
-    const collection = {
-      name: collectionProtoObject.name,
-      items: this.getSingleCollectionData(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 {
-        if (collection.sort.order === 'asc') {
-          return a[collection.sort.by] > b[collection.sort.by] ? 1 : -1
-        }
-
-        return a[collection.sort.by] < b[collection.sort.by] ? 1 : -1
-      }
-    })
-
-    return collection
-  }
-
-  clearCollectionOutputDir(collectionName) {
-    const collectionDirectoryPath = path.join(process.cwd(), this.config.markup.out, collectionName)
-    deleteDirectory(collectionDirectoryPath) // Remove collection directory
-  }
-
-  getRelativePathPrefix(outputDir, fromDir) {
-    let relativeDir = path.relative(process.cwd(), outputDir)
-    const fromRelativeDir = fromDir ? path.relative(process.cwd(), fromDir) : ''
-
-    if (fromRelativeDir && relativeDir.startsWith(fromRelativeDir)) {
-      relativeDir = relativeDir.replace(fromRelativeDir, '')
-    }
-
-    return this.getUpDirPrefix(relativeDir)
-  }
-
-  getUpDirPrefix(relativeDir) {
-    if (relativeDir.trim() === '') return ''
-    if (relativeDir.startsWith(path.sep)) relativeDir = relativeDir.slice(1)
-    if (relativeDir.endsWith(path.sep)) relativeDir = relativeDir.slice(0, -1)
-    const relativePathParts = relativeDir.split(path.sep)
-    let upDir = ''
-    for (let i = 0; i < relativePathParts.length; i++) {
-      upDir += `..${path.sep}`
-    }
-    return upDir
-  }
+    markupDefaultExcludes.push('_*')
+    markupDefaultExcludes = [...new Set(markupDefaultExcludes)]
 
-  getPageUrl(outputPath) {
-    outputPath = this.replaceOutExtensions(outputPath)
-    return /index\.[a-z]+$/.test(path.basename(outputPath)) ? path.relative(process.cwd(), path.dirname(outputPath)) : path.relative(process.cwd(), outputPath)
+    return `!(${markupDefaultExcludes.join('|')})/**/*.+(${this.engine.markupExtensions})`
   }
 
-  replaceOutExtensions(outputPath) {
-    switch (path.extname(outputPath)) {
-      case '.md':
-        outputPath = outputPath.replace(/\.md$/, '.html')
-        break
-      case '.njk':
-        outputPath = outputPath.replace(/\.njk$/, '.html')
-        break
-    }
-
-    return outputPath
-  }
-
-  compileEntry(templateName, additionalContext) {
+  async compileEntry(templateName, additionalContext) {
     const context = { page: {} }
     let pageUrl
 
@@ -409,184 +152,205 @@ export default class Markups {
       const frontMatterResult = parseFrontMatter(templateName)
       context.page = frontMatterResult.frontMatter
     } catch (err) {
-      console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset}${pstyle.dim} Failed parsing front matter:${pstyle.reset} ${pstyle.italic + pstyle.underline}${templateName}${pstyle.reset}`)
-      console.log(err)
+      log({ tag: 'error', text: 'Failed parsing front matter:', link: templateName })
+      console.error(err)
     }
 
     if (pageUrl) context.page.url = pageUrl
 
-    const env = this.nunjucksEnv
-    return new Promise((resolve, reject) => {
-      env.getTemplate(templateName).render(context, (error, result) => {
-        if (!error) {
-          resolve(result)
-        } else {
-          reject(error)
-        }
-      })
-    })
-  }
+    const frontMatter = context.page
 
-  getCollectionIndexFile(collectionName) {
-    const indexFiles = globSync(path.join(process.cwd(), this.config.markup.in, collectionName, 'index.+(html|njk|md)'))
-    if (indexFiles.length === 0) return null
-    return indexFiles[0]
-  }
+    if (frontMatter && frontMatter.published === false) {
+      return { result: '', frontMatter, skipped: true }
+    }
 
-  buildCollectionPaginationData(collectionData) {
-    if (!collectionData) return
+    const result = await this.engine.render(templateName, context)
+    return { result, frontMatter }
+  }
 
-    for (const collectionName of Object.keys(collectionData)) {
-      const collection = collectionData[collectionName]
+  async compileDirectory(markupIn, collectionData, pageEntries) {
+    const markupStart = performance.now()
+    const markupFiles = [
+      ...globSync(path.join(markupIn, this.generateMarkupGlobPattern(this.includePaths))),
+      ...globSync(path.join(markupIn, `*.+(${this.engine.markupExtensions})`))
+    ]
+    const compilePromises = []
+    const indexableExtensions = this.engine.indexableExtensions
 
-      if (!collection.paginate) continue
+    for (const file of markupFiles) {
+      const relativePath = path.relative(markupIn, file)
+      const relativePathParts = relativePath.split(path.sep)
 
-      collection.pages = []
-      let pageItems = []
-      for (const item of collection.items) {
-        if (pageItems.length === collection.paginate) {
-          collection.pages.push(pageItems)
-          pageItems = []
-        }
-        pageItems.push(item)
+      if (relativePathParts.length > 1 &&
+        collectionData[relativePathParts[0]] &&
+        relativePathParts[1].startsWith('index.') && indexableExtensions.has(path.extname(relativePathParts[1])) &&
+        collectionData[relativePathParts[0]].items.length > 0) {
+        continue
       }
-      collection.pages.push(pageItems)
-
-      collection.totalPages = collection.pages.length
-    }
-  }
 
-  generateCollectionPaginationPages(collectionData, compilePromises) {
-    if (!collectionData) return
+      let markupOut = path.join(process.cwd(), this.markupOut, relativePath)
+      const fromPath = path.join(process.cwd(), this.markupOut)
+      const markupOutDir = path.dirname(markupOut)
 
-    for (const collectionName of Object.keys(collectionData)) {
-      const collection = collectionData[collectionName]
-      const file = this.getCollectionIndexFile(collectionName)
+      mkDir(markupOutDir)
 
-      if (!collection.totalPages || collection.totalPages === 0) {
-        collection.totalPages = 1
-        collection.pages = [collection.items]
+      const fileContext = {
+        ...collectionData,
+        relativePathPrefix: getRelativePathPrefix(markupOutDir, fromPath),
+        _url: getPageUrl(markupOut)
       }
 
-      for (let i = 0; i < collection.totalPages; i++) {
-        collection.pageItems = collection.pages[i]
-        collection.pageNumber = i + 1
-        collection.pageUrl = collection.pageNumber === 1 ? collection.name : `${collection.name}/${collection.pageNumber}`
-        collection.nextPage = collection.pageNumber === collection.totalPages ? null : collection.pageNumber + 1
-        collection.nextPageUrl = collection.pageNumber === collection.totalPages ? null : `${collection.name}/${collection.pageNumber + 1}`
-        collection.prevPage = collection.pageNumber === 1 ? null : collection.pageNumber - 1
-        collection.prevPageUrl = collection.pageNumber === 1 ? null : `${collection.name}/${collection.pageNumber - 1}`
-        if (collection.prevPage === 1) {
-          collection.prevPageUrl = collection.name
+      const shouldIndex = pageEntries && indexableExtensions.has(path.extname(file))
+      const fileCollection = relativePathParts.length > 1 && collectionData[relativePathParts[0]]
+        ? relativePathParts[0]
+        : null
+
+      const compilePromise = this.compileEntry(file, fileContext).then(({ result, frontMatter, skipped }) => {
+        if (skipped) {
+          const outFile = replaceOutExtensions(markupOut)
+          if (fs.existsSync(outFile)) {
+            fs.unlinkSync(outFile)
+            log({ tag: this.logTag, text: 'Removed unpublished:', link: path.relative(process.cwd(), outFile) })
+          }
+          return
         }
+        markupOut = replaceOutExtensions(markupOut)
+        fs.writeFileSync(markupOut, result)
 
-        const markupOut = path.join(process.cwd(), this.config.markup.out, collection.pageUrl, 'index.html')
-        const fromPath = path.join(process.cwd(), this.config.markup.out)
-        const markupOutDir = path.dirname(markupOut)
+        if (shouldIndex && frontMatter.published !== false) {
+          if (!frontMatter.title) frontMatter.title = path.basename(file, path.extname(file))
+          if (fileCollection && !frontMatter.collection) frontMatter.collection = fileCollection
 
-        mkDir(markupOutDir)
+          pageEntries.push({
+            ...frontMatter,
+            url: getPageUrlRelativeToOutput(markupOut, this.markupOut),
+            content: result,
+            isIndex: false
+          })
+        }
+      })
+      compilePromises.push(compilePromise)
+    }
 
-        collectionData.relativePathPrefix = this.getRelativePathPrefix(markupOutDir, fromPath)
-        collectionData._url = this.getPageUrl(markupOut)
+    try {
+      await Promise.all(compilePromises)
+      const markupEnd = performance.now()
+      log({ tag: this.logTag, text: `Compiled: ${markupFiles.length} file${markupFiles.length > 1 ? 's' : ''} into`, link: this.markupOut, time: buildTime(markupStart, markupEnd) })
+    } catch (err) {
+      log({ tag: this.logTag, error: true, text: 'Failed compiling' })
+      console.error(err)
+      throw err
+    } finally {
+      clearFrontMatterCache()
+    }
+  }
+
+  async compileSingleFile(markupIn, collectionData, pageEntries) {
+    const markupStart = performance.now()
+    let markupOut = path.join(process.cwd(), this.markupOut)
+    const markupOutDir = path.dirname(markupOut)
+    const indexableExtensions = this.engine.indexableExtensions
+    mkDir(markupOutDir)
+
+    const fileContext = {
+      ...collectionData,
+      relativePathPrefix: getRelativePathPrefix(markupOutDir),
+      _url: getPageUrl(markupOut)
+    }
 
-        if (!file) {
-          continue
+    const shouldIndex = pageEntries && indexableExtensions.has(path.extname(markupIn))
+
+    try {
+      const { result, frontMatter, skipped } = await this.compileEntry(markupIn, fileContext)
+      markupOut = replaceOutExtensions(markupOut)
+
+      if (skipped) {
+        if (fs.existsSync(markupOut)) {
+          fs.unlinkSync(markupOut)
+          log({ tag: this.logTag, text: 'Removed unpublished:', link: path.relative(process.cwd(), markupOut) })
         }
+        return
+      }
+
+      fs.writeFileSync(markupOut, result)
 
-        const compilePromise = this.compileEntry(file, collectionData).then((result) => {
-          fs.writeFileSync(markupOut, result)
+      if (shouldIndex && frontMatter.published !== false) {
+        if (!frontMatter.title) frontMatter.title = path.basename(markupIn, path.extname(markupIn))
+        pageEntries.push({
+          ...frontMatter,
+          url: getPageUrlRelativeToOutput(markupOut, this.markupOut),
+          content: result,
+          isIndex: false
         })
-        compilePromises.push(compilePromise)
       }
+
+      const markupEnd = performance.now()
+      log({ tag: this.logTag, text: 'Compiled:', link: path.relative(process.cwd(), path.join(process.cwd(), this.markupOut, path.basename(markupIn))), time: buildTime(markupStart, markupEnd) })
+    } catch (err) {
+      log({ tag: this.logTag, error: true, text: 'Failed compiling:', link: path.relative(process.cwd(), path.join(process.cwd(), this.markupOut, path.basename(markupIn))) })
+      console.error(err)
+      throw err
+    } finally {
+      clearFrontMatterCache()
     }
   }
 
-  compile() {
-    if (!this.config.markup || !this.config.markup.in) return
+  async compile() {
+    const moduleConfig = this.config.markup
+    if (!moduleConfig || !moduleConfig.in) return
 
-    if (this.config.ssgData) {
-      for (const [name, html] of Object.entries(this.config.ssgData)) {
-        this.nunjucksEnv.addGlobal(name, html)
+    if (this.config.reactorData) {
+      for (const [name, html] of Object.entries(this.config.reactorData)) {
+        this.engine.setGlobal(name, html)
       }
     }
 
-    const markupIn = path.join(process.cwd(), this.config.markup.in)
-    const compilePromises = []
+    const markupIn = path.join(process.cwd(), this.markupIn)
 
     if (!pathExists(markupIn)) {
-      console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset} ${pstyle.dim}Markup path does not exist:${pstyle.reset} ${pstyle.italic + pstyle.underline}${markupIn}${pstyle.reset}`)
+      log({ tag: 'error', text: 'Markup path does not exist:', link: markupIn })
       return
     }
 
     const collectionData = {
-      ...this.collectionAutoDiscovery(),
-      ...this.getCollectionDataBasedOnConfig(this.config.markup.options.collections)
+      ...collectionAutoDiscovery(this.markupIn),
+      ...getCollectionDataBasedOnConfig(this.markupIn, this.collectionsConfig)
     }
 
-    // Create collection pages
-    this.buildCollectionPaginationData(collectionData)
-    this.generateCollectionPaginationPages(collectionData, compilePromises)
+    const shouldIndex = this.searchIndexConfig || this.sitemapConfig
+    const pageEntries = shouldIndex ? [] : null
 
-    if (pathIsDirectory(markupIn)) {
-      const markupFiles = [...globSync(path.join(markupIn, this.generateMarkupGlobPattern(this.includePaths))), ...globSync(path.join(markupIn, '*.+(html|xml|rss|atom|json|njk|md)'))]
+    buildCollectionPaginationData(collectionData)
+    const collectionPromises = generateCollectionPaginationPages(collectionData, this.markupIn, this.markupOut, this.compileEntry.bind(this))
 
-      markupFiles.forEach((file) => {
-        const relativePath = path.relative(markupIn, file)
-        const relativePathParts = relativePath.split(path.sep)
+    await Promise.all(collectionPromises)
 
-        // Collection pages already generated, skip them
-        if (relativePathParts.length > 1 &&
-          collectionData[relativePathParts[0]] &&
-          /^index\.(html|njk|md)$/.test(relativePathParts[1]) &&
-          collectionData[relativePathParts[0]].items.length > 0) {
-          return
-        }
+    if (pageEntries) {
+      for (const collectionName of Object.keys(collectionData)) {
+        const collection = collectionData[collectionName]
+        const totalPages = collection.totalPages || 1
 
-        let markupOut = path.join(process.cwd(), this.config.markup.out, relativePath)
-        const fromPath = path.join(process.cwd(), this.config.markup.out)
-        const markupOutDir = path.dirname(markupOut)
-
-        mkDir(markupOutDir)
-
-        collectionData.relativePathPrefix = this.getRelativePathPrefix(markupOutDir, fromPath)
-        collectionData._url = this.getPageUrl(markupOut)
-
-        const compilePromise = this.compileEntry(file, collectionData).then((result) => {
-          markupOut = this.replaceOutExtensions(markupOut)
-          fs.writeFileSync(markupOut, result)
-        })
-        compilePromises.push(compilePromise)
-      })
+        for (let i = 0; i < totalPages; i++) {
+          const pageUrl = i === 0 ? collectionName : `${collectionName}/${i + 1}`
+          pageEntries.push({
+            url: pageUrl,
+            title: collectionName,
+            isIndex: true
+          })
+        }
+      }
+    }
 
-      return new Promise((resolve, reject) => {
-        Promise.all(compilePromises).then(() => {
-          console.log(`${pstyle.cyanBright + pstyle.bold}[markup]${pstyle.reset} ${pstyle.dim}Compiled: ${pstyle.reset}${markupFiles.length} file${markupFiles.length > 1 ? 's' : ''} into ${pstyle.italic + pstyle.underline}${this.config.markup.out}${pstyle.reset}`)
-          clearFrontMatterCache()
-          resolve()
-        }).catch((err) => {
-          console.log(`${pstyle.cyanBright + pstyle.bold}[markup]${pstyle.reset} ${pstyle.redBright + pstyle.bold}[error]${pstyle.reset} ${pstyle.dim}Failed compiling${pstyle.reset + pstyle.bell}`)
-          console.log(err)
-          clearFrontMatterCache()
-          reject(err)
-        })
-      })
+    if (pathIsDirectory(markupIn)) {
+      await this.compileDirectory(markupIn, collectionData, pageEntries)
     } else {
-      let markupOut = path.join(process.cwd(), this.config.markup.out)
-      const markupOutDir = path.dirname(markupOut)
-      mkDir(markupOutDir)
-
-      collectionData.relativePathPrefix = this.getRelativePathPrefix(markupOutDir)
-      collectionData._url = this.getPageUrl(markupOut)
+      await this.compileSingleFile(markupIn, collectionData, pageEntries)
+    }
 
-      return this.compileEntry(markupIn, collectionData).then((result) => {
-        markupOut = this.replaceOutExtensions(markupOut)
-        fs.writeFileSync(markupOut, result)
-        console.log(`${pstyle.cyanBright + pstyle.bold}[markup]${pstyle.reset} ${pstyle.dim}Compiled:${pstyle.reset} ${pstyle.italic + pstyle.underline}${path.relative(process.cwd(), path.join(process.cwd(), this.config.markup.out, path.basename(markupIn)))}${pstyle.reset}`)
-        clearFrontMatterCache()
-      }).catch((err) => {
-        console.log(`${pstyle.cyanBright + pstyle.bold}[markup]${pstyle.reset} ${pstyle.redBright + pstyle.bold}[error]${pstyle.reset} ${pstyle.dim}Failed compiling:${pstyle.reset} ${pstyle.italic + pstyle.underline}${path.relative(process.cwd(), path.join(process.cwd(), this.config.markup.out, path.basename(markupIn)))}${pstyle.reset + pstyle.bell}`)
-        console.log(err)
-        clearFrontMatterCache()
+    if (shouldIndex && pageEntries) {
+      generateIndexFiles(pageEntries, this.markupOut, this.siteData.url, {
+        searchIndex: this.searchIndexConfig,
+        sitemap: this.sitemapConfig
       })
     }
   }