poops 1.2.2 → 1.2.4

package/poops.js

@@ -9,11 +9,12 @@ import os from 'node:os'
 import fs from 'node:fs'
 import livereload from 'livereload'
 import Markups from './lib/markups.js'
+import Images from './lib/images.js'
 import path from 'node:path'
 import serveStatic from 'serve-static'
 import Reactor from './lib/reactor.js'
 import Scripts from './lib/scripts.js'
-import log, { styledLog } from './lib/utils/log.js'
+import log, { styledLog, hasLoggedErrors } from './lib/utils/log.js'
 import Styles from './lib/styles.js'
 import PostCSS from './lib/postcss.js'
 import Argoyle from 'argoyle'
@@ -28,6 +29,7 @@ const cli = new Argoyle(pkg.version)
   .option('config', { short: 'c', value: '<path>', description: 'Specify the config file' })
   .option('port', { short: 'p', value: '<number>', description: 'Specify the port for the server, overrides the config file' })
   .option('livereload-port', { short: 'l', value: '<number>', description: 'Specify the port for the livereload server, overrides the config file' })
+  .option('base-url', { short: 'u', value: '<path>', description: 'Set the base URL prefix for markup, overrides the config file' })
 
 let flags, positionals
 try {
@@ -41,6 +43,7 @@ const build = flags.build
 const defaultConfigPath = flags.config || positionals[0] || 'poops.json'
 const overridePort = flags.port
 const overrideLivereloadPort = flags['livereload-port']
+const overrideBaseURL = flags['base-url']
 
 let configPath = path.join(cwd, defaultConfigPath)
 if (!pathExists(configPath)) configPath = path.join(cwd, '💩.json') // TODO: Ok dude, I know it's late, but you can do better than this.
@@ -70,7 +73,9 @@ function setupLiveReloadServer(config) {
 
   const liveReloadServer = livereload.createServer({
     exclusions: [...new Set(liveReloadExcludes)],
-    port: config.livereload_port
+    port: config.livereload_port,
+    exts: config.livereload.exts, // replaces the default watched extensions
+    extraExts: config.livereload.extraExts // adds to the defaults
   })
   styledLog(`🔃 {dim}LiveReload  :{/} ${liveReloadServer.config.port}`)
   console.log()
@@ -82,7 +87,15 @@ function setupWatchers(config, modules) {
 
   // TODO: think about watching the updates of the config file itself, we can reload the config and recompile everything.
   // TODO: ability to automatically create a watch list of directories if watch is set to true. The list will be generated from the `in` property of each task.
-  chokidar.watch(config.watch, { ignoreInitial: true }).on('change', (file) => {
+  // awaitWriteFinish: wait for saves to finish writing before recompiling, so a
+  // mid-write (truncated/partial) file is never read. Fixes intermittent broken
+  // builds on editor save. Bump thresholds if slow disks flake.
+  // Shared by 'change' and 'add': editors with atomic saves (rename-write)
+  // fire unlink+add instead of change, so both events must trigger the same
+  // rebuilds. 'add' also covers genuinely new files (e.g. a new markup page).
+  // Rebuild branches shared by change/add/deletion: a deletion needs the same
+  // rebuilds (a deleted-but-still-imported file must surface the error).
+  const rebuild = (file) => {
     if (/(\.m?jsx?|\.tsx?)$/i.test(file)) {
       modules.scripts.compile().catch(err => console.error(err))
 
@@ -102,26 +115,79 @@ function setupWatchers(config, modules) {
       modules.markups.compile().then(() => modules.postcss.compile()).catch(err => console.error(err))
     }
 
-    // TODO: We can actually reload the page only if the data file from data has changed.
     if (/(\.json|\.ya?ml)$/i.test(file)) {
       modules.markups.reloadDataFiles().then(() => modules.markups.compile()).catch(err => console.error(err))
     }
+  }
 
+  // Source image extensions handled by poops-images. The doesFileBelongToPath
+  // guard (against config.images.in) also breaks the feedback loop: generated
+  // variants land in the `out` dir, never in `in`, so they don't retrigger.
+  const imageExtRe = /(\.jpe?g|\.png|\.tiff?|\.webp|\.heic|\.heif|\.svg|\.gif)$/i
+  const belongsToImages = (file) => imageExtRe.test(file) && doesFileBelongToPath(file, config.images)
+
+  const compileChanged = (file) => {
+    rebuild(file)
+    if (belongsToImages(file)) {
+      modules.images.compile()
+        .then(() => modules.markups.compile())
+        .then(() => modules.postcss.compile())
+        .catch(err => console.error(err))
+    }
     doesFileBelongToPath(file, config.copy) && modules.copy.execute().catch(err => console.error(err))
-  }).on('unlink', (file) => {
-    if (/(\.html|\.xml|\.rss|\.atom|\.njk|\.liquid|\.md)$/i.test(file)) {
-      modules.markups.compile().catch(err => console.error(err))
+  }
+
+  // Atomic-save editors (rename-write) fire unlink+add for every save, so an
+  // unlink only counts as a real deletion if no add for the same path follows
+  // within the settle window. Must outlive the 150ms awaitWriteFinish delay
+  // on 'add'. Fixed 300ms; make configurable if slow disks flake.
+  const UNLINK_SETTLE_MS = 300
+  const pendingUnlinks = new Map()
+
+  const scheduleUnlink = (target, handler) => {
+    clearTimeout(pendingUnlinks.get(target))
+    pendingUnlinks.set(target, setTimeout(() => {
+      pendingUnlinks.delete(target)
+      handler(target)
+    }, UNLINK_SETTLE_MS))
+  }
+
+  const handleDeleted = (file) => {
+    modules.markups.removeOutput(file)
+    if (belongsToImages(file)) {
+      // Deleted source: drop its variants + cache entry, then recompile markup
+      // so galleries/srcsets reading the image cache no longer reference it.
+      modules.images.remove(file)
+        .then(() => modules.markups.compile())
+        .then(() => modules.postcss.compile())
+        .catch(err => console.error(err))
     }
+    rebuild(file)
     modules.copy.unlink(file, doesFileBelongToPath(file, config.copy))
-  }).on('unlinkDir', (dirPath) => {
-    doesFileBelongToPath(dirPath, config.markup) && modules.markups.compile().catch(err => console.error(err))
-    modules.copy.unlink(dirPath, doesFileBelongToPath(dirPath, config.copy))
-  }).on('add', (file) => {
-    if (/(\.json|\.ya?ml)$/i.test(file)) {
-      modules.markups.reloadDataFiles().then(() => modules.markups.compile()).catch(err => console.error(err))
+  }
+
+  const handleDeletedDir = (dirPath) => {
+    modules.markups.removeOutput(dirPath)
+    if (doesFileBelongToPath(dirPath, config.markup)) {
+      modules.markups.compile().then(() => modules.postcss.compile()).catch(err => console.error(err))
     }
-    doesFileBelongToPath(file, config.copy) && modules.copy.execute().catch(err => console.error(err))
-  })
+    modules.copy.unlink(dirPath, doesFileBelongToPath(dirPath, config.copy))
+  }
+
+  chokidar.watch(config.watch, {
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 150, pollInterval: 50 }
+  }).on('change', compileChanged)
+    .on('add', (file) => {
+      const pending = pendingUnlinks.get(file)
+      if (pending) {
+        clearTimeout(pending)
+        pendingUnlinks.delete(file)
+      }
+      compileChanged(file)
+    })
+    .on('unlink', (file) => scheduleUnlink(file, handleDeleted))
+    .on('unlinkDir', (dirPath) => scheduleUnlink(dirPath, handleDeletedDir))
 }
 
 // Main function 💩
@@ -130,22 +196,32 @@ async function poops() {
   const postcss = new PostCSS(config)
   const reactor = new Reactor(config)
   const scripts = new Scripts(config)
+  const images = new Images(config)
   const markups = new Markups(config)
   const copy = new Copy(config)
 
-  try { await styles.compile() } catch (err) { console.error(err) }
-  try { await reactor.compile() } catch (err) { console.error(err) }
+  // Thrown errors are caught so one failing step doesn't stop the rest;
+  // `failed` + hasLoggedErrors() (module-internal, swallowed errors) decide
+  // the build exit code, so a broken compile can't ship as a green build.
+  let failed = false
+  const step = async(task) => {
+    try { await task() } catch (err) { failed = true; console.error(err) }
+  }
+
+  await step(() => styles.compile())
+  await step(() => reactor.compile())
   config.reactorData = reactor.getRendered()
-  try { await scripts.compile() } catch (err) { console.error(err) }
-  try { await markups.compile() } catch (err) { console.error(err) }
-  try { await postcss.compile() } catch (err) { console.error(err) }
-  try { await copy.execute() } catch (err) { console.error(err) }
+  await step(() => scripts.compile())
+  await step(() => images.compile()) // before markups: engines read the poops-images cache
+  await step(() => markups.compile())
+  await step(() => postcss.compile())
+  await step(() => copy.execute())
 
   if (build || (!config.watch && !config.livereload && !config.serve)) {
-    process.exit(0)
+    process.exit(failed || hasLoggedErrors() ? 1 : 0)
   }
 
-  setupWatchers(config, { styles, postcss, reactor, scripts, markups, copy })
+  setupWatchers(config, { styles, postcss, reactor, scripts, images, markups, copy })
 }
 
 // CLI Header
@@ -179,6 +255,16 @@ if (!config.reactor && config.ssg) {
   config.reactor = config.ssg
 }
 
+if (overrideBaseURL && config.markup) {
+  config.markup.baseURL = overrideBaseURL
+}
+
+// poops-images resolves custom handlers/composites relative to the config file;
+// without this it would default to cwd. Matches poops-images' own loadConfig.
+if (config.images && typeof config.images === 'object' && config.images.configDir === undefined) {
+  config.images.configDir = path.dirname(configPath)
+}
+
 async function getAvailablePort(port, max) {
   while (port < max) {
     const status = await portscanner.checkPortStatus(port, 'localhost')
@@ -238,6 +324,11 @@ async function startServer() {
 // Start the webserver
 if (!build && config.serve) {
   startServer()
+} else if (!build && config.livereload) {
+  // livereload without serve: still needs the livereload server
+  resolveLiveReloadPort(config)
+    .then(poops)
+    .then(() => setupLiveReloadServer(config))
 } else {
   poops()
 }