poops 1.2.3 → 1.2.4

package/lib/postcss.js

@@ -1,14 +1,13 @@
-import { transform } from 'esbuild'
 import fs from 'node:fs'
 import {
   pathExists,
   mkPath,
-  insertMinSuffix,
   buildStyleOutputFilePath,
   fillBannerTemplate,
   buildTime,
   fileSize
 } from './utils/helpers.js'
+import minifyToFile from './utils/minify.js'
 import log from './utils/log.js'
 
 let postcss
@@ -65,10 +64,13 @@ export default class PostCSS {
 
     this.config.postcss = Array.isArray(this.config.postcss) ? this.config.postcss : [this.config.postcss]
     for (const entry of this.config.postcss) {
-      if (entry.in && entry.out && pathExists(entry.in)) {
-        mkPath(entry.out)
-        await this.compileEntry(entry.in, entry.out, entry.options)
+      if (!entry.in || !entry.out) continue
+      if (!pathExists(entry.in)) {
+        log({ tag: 'postcss', error: true, text: 'Entry does not exist:', link: entry.in })
+        continue
       }
+      mkPath(entry.out)
+      await this.compileEntry(entry.in, entry.out, entry.options)
     }
   }
 
@@ -98,30 +100,14 @@ export default class PostCSS {
     const end = performance.now()
     if (!options.justMinified) log({ tag: 'postcss', text: 'Compiled:', link: outfilePath, size: fileSize(outfilePath), time: buildTime(start, end) })
 
-    const minPath = insertMinSuffix(outfilePath)
-    if (options.minify) {
-      try {
-        const minStart = !options.justMinified ? performance.now() : start
-
-        const minified = await transform(css, {
-          loader: 'css',
-          minify: true
-        })
-
-        if (this.banner) minified.code = this.banner + '\n' + minified.code
-        fs.writeFileSync(minPath, minified.code)
-        const minEnd = performance.now()
-        log({ tag: 'postcss', text: 'Compiled:', link: minPath, size: fileSize(minPath), time: buildTime(minStart, minEnd) })
-      } catch (err) {
-        log({ tag: 'postcss', error: true, text: 'Failed compiling:', link: minPath })
-        console.error(err)
-      }
-
-      if (options.justMinified) {
-        fs.unlinkSync(outfilePath)
-      }
-    } else {
-      if (pathExists(minPath)) fs.unlinkSync(minPath)
-    }
+    await minifyToFile({
+      outfilePath,
+      loader: 'css',
+      code: css,
+      banner: this.banner,
+      tag: 'postcss',
+      options,
+      startTime: options.justMinified ? start : undefined
+    })
   }
 }

package/lib/reactor.js

@@ -1,14 +1,14 @@
-import { build, transform } from 'esbuild'
+import { build } from 'esbuild'
 import { deepMerge } from 'book-of-spells'
 import {
   pathExists,
   mkPath,
-  insertMinSuffix,
   pathContainsPathSegment,
   fillBannerTemplate,
   buildTime,
   fileSize
 } from './utils/helpers.js'
+import minifyToFile from './utils/minify.js'
 import fs from 'node:fs'
 import path from 'node:path'
 import { createRequire } from 'node:module'
@@ -29,9 +29,12 @@ export default class Reactor {
     this.rendered = {}
 
     for (const entry of this.config.reactor) {
-      if (entry.component && entry.inject && pathExists(entry.component)) {
-        await this.compileEntry(entry)
+      if (!entry.component || !entry.inject) continue
+      if (!pathExists(entry.component)) {
+        log({ tag: 'reactor', error: true, text: 'Component does not exist:', link: entry.component })
+        continue
       }
+      await this.compileEntry(entry)
     }
 
     this.renderedChanged = JSON.stringify(this.rendered) !== JSON.stringify(prevRendered)
@@ -83,6 +86,9 @@ export const html = renderToString(React.createElement(Component));
     }
 
     // --- Step 2: Bundle the client entry for the browser ---
+    if (client && out && !pathExists(client)) {
+      log({ tag: 'reactor', error: true, text: 'Entry does not exist:', link: client })
+    }
     if (client && out && pathExists(client)) {
       mkPath(out)
 
@@ -129,31 +135,7 @@ export const html = renderToString(React.createElement(Component));
       if (!options.justMinified) log({ tag: 'reactor', text: 'Compiled:', link: out, size: fileSize(out), time: buildTime(esbuildStart, esbuildEnd) })
       if (options.sourcemap) log({ tag: 'reactor', text: 'Compiled:', link: `${out}.map` })
 
-      if (options.minify) {
-        const minPath = insertMinSuffix(out)
-        try {
-          const terserStart = performance.now()
-          const minifyResult = await transform(fs.readFileSync(out, 'utf-8'), {
-            minify: true,
-            loader: 'js'
-          })
-          const terserEnd = performance.now()
-
-          if (this.banner) minifyResult.code = this.banner + '\n' + minifyResult.code
-          fs.writeFileSync(minPath, minifyResult.code)
-          log({ tag: 'reactor', text: 'Compiled:', link: minPath, size: fileSize(minPath), time: buildTime(terserStart, terserEnd) })
-        } catch (err) {
-          log({ tag: 'reactor', error: true, text: 'Failed compiling:', link: minPath })
-          console.error(err)
-        }
-
-        if (options.justMinified) {
-          fs.unlinkSync(out)
-        }
-      } else {
-        const minPath = insertMinSuffix(out)
-        if (pathExists(minPath)) fs.unlinkSync(minPath)
-      }
+      await minifyToFile({ outfilePath: out, loader: 'js', banner: this.banner, tag: 'reactor', options })
     }
   }
 

package/lib/scripts.js

@@ -1,16 +1,15 @@
-import { build, transform } from 'esbuild'
+import { build } from 'esbuild'
+import { globSync, hasMagic } from 'glob'
 import { deepMerge } from 'book-of-spells'
 import {
   pathExists,
   mkPath,
   pathForFile,
-  insertMinSuffix,
-  buildScriptOutputFilePath,
   fillBannerTemplate,
   buildTime,
   fileSize
 } from './utils/helpers.js'
-import fs from 'node:fs'
+import minifyToFile from './utils/minify.js'
 import log from './utils/log.js'
 
 export default class Scripts {
@@ -24,10 +23,30 @@ export default class Scripts {
     this.config.scripts = Array.isArray(this.config.scripts) ? this.config.scripts : [this.config.scripts]
 
     for (const scriptEntry of this.config.scripts) {
-      if (scriptEntry.in && scriptEntry.out && pathExists(scriptEntry.in)) {
-        mkPath(scriptEntry.out)
-        await this.compileEntry(scriptEntry.in, scriptEntry.out, scriptEntry.options)
+      if (!scriptEntry.in || !scriptEntry.out) continue
+      // `in` may be an array of entry points — pathExists on an array throws
+      const configured = Array.isArray(scriptEntry.in) ? scriptEntry.in : [scriptEntry.in]
+      const entryPoints = []
+      let missing = false
+      for (const entry of configured) {
+        if (hasMagic(entry)) {
+          // Globs must use `/` even on Windows; sort for deterministic build order
+          const matches = globSync(entry, { posix: true }).sort()
+          if (!matches.length) {
+            log({ tag: 'script', error: true, text: 'Entry does not exist:', link: entry })
+            missing = true
+          }
+          entryPoints.push(...matches)
+        } else if (!pathExists(entry)) {
+          log({ tag: 'script', error: true, text: 'Entry does not exist:', link: entry })
+          missing = true
+        } else {
+          entryPoints.push(entry)
+        }
       }
+      if (missing) continue
+      mkPath(scriptEntry.out)
+      await this.compileEntry(entryPoints, scriptEntry.out, scriptEntry.options)
     }
   }
 
@@ -73,9 +92,16 @@ export default class Scripts {
 
     deepMerge(opts, optionsClone) // ability to pass other esbuild options `node_modules/esbuild/lib/main.d.ts`
 
+    // Multi-dir entry points nest output under their common ancestor (esbuild's
+    // outbase), so output paths can't be derived from basenames — read them
+    // from the metafile instead. Keys are relative to absWorkingDir.
+    opts.metafile = true
+    opts.absWorkingDir = process.cwd()
+
     const esbuildStart = performance.now()
+    let result
     try {
-      await build(opts)
+      result = await build(opts)
     } catch (err) {
       log({ tag, error: true, text: 'Failed compiling:', link: outfilePath })
       console.error(err)
@@ -83,36 +109,13 @@ export default class Scripts {
     }
     const esbuildEnd = performance.now()
 
-    for (const entry of infilePath) {
-      const newOutFilePath = buildScriptOutputFilePath(entry, outfilePath)
-      const minPath = insertMinSuffix(newOutFilePath)
+    for (const [newOutFilePath, output] of Object.entries(result.metafile.outputs)) {
+      if (!output.entryPoint) continue // sourcemaps, chunks
 
       if (!options.justMinified) log({ tag, text: 'Compiled:', link: newOutFilePath, size: fileSize(newOutFilePath), time: buildTime(esbuildStart, esbuildEnd) })
       if (options.sourcemap) log({ tag, text: 'Compiled:', link: `${newOutFilePath}.map` })
 
-      if (options.minify) {
-        try {
-          const terserStart = performance.now()
-          const minifyResult = await transform(fs.readFileSync(newOutFilePath, 'utf-8'), {
-            minify: true,
-            loader: 'js'
-          })
-          const terserEnd = performance.now()
-
-          if (this.banner) minifyResult.code = this.banner + '\n' + minifyResult.code
-          fs.writeFileSync(minPath, minifyResult.code)
-          log({ tag, text: 'Compiled:', link: minPath, size: fileSize(minPath), time: buildTime(terserStart, terserEnd) })
-        } catch (err) {
-          log({ tag, error: true, text: 'Failed compiling:', link: minPath })
-          console.error(err)
-        }
-
-        if (options.justMinified) {
-          fs.unlinkSync(newOutFilePath)
-        }
-      } else {
-        if (pathExists(minPath)) fs.unlinkSync(minPath)
-      }
+      await minifyToFile({ outfilePath: newOutFilePath, loader: 'js', banner: this.banner, tag, options })
     }
   }
 }

package/lib/styles.js

@@ -1,14 +1,13 @@
-import { transform } from 'esbuild'
 import fs from 'node:fs'
 import {
   pathExists,
   mkPath,
-  insertMinSuffix,
   buildStyleOutputFilePath,
   fillBannerTemplate,
   buildTime,
   fileSize
 } from './utils/helpers.js'
+import minifyToFile from './utils/minify.js'
 import path from 'node:path'
 import * as sass from 'sass'
 import log from './utils/log.js'
@@ -25,10 +24,13 @@ export default class Styles {
     if (!this.config.styles) return
     this.config.styles = Array.isArray(this.config.styles) ? this.config.styles : [this.config.styles]
     for (const styleEntry of this.config.styles) {
-      if (styleEntry.in && styleEntry.out && pathExists(styleEntry.in)) {
-        mkPath(styleEntry.out)
-        await this.compileEntry(styleEntry.in, styleEntry.out, styleEntry.options)
+      if (!styleEntry.in || !styleEntry.out) continue
+      if (!pathExists(styleEntry.in)) {
+        log({ tag: 'style', error: true, text: 'Entry does not exist:', link: styleEntry.in })
+        continue
       }
+      mkPath(styleEntry.out)
+      await this.compileEntry(styleEntry.in, styleEntry.out, styleEntry.options)
     }
   }
 
@@ -55,7 +57,7 @@ export default class Styles {
       opts.sourceMapIncludeSources = options.sourcemap
     }
 
-    outfilePath = buildStyleOutputFilePath(infilePath, outfilePath, options)
+    outfilePath = buildStyleOutputFilePath(infilePath, outfilePath)
 
     const stylesStart = performance.now()
     let compiledSass
@@ -79,30 +81,14 @@ export default class Styles {
       log({ tag: 'style', text: 'Compiled:', link: `${outfilePath}.map` })
     }
 
-    const minPath = insertMinSuffix(outfilePath)
-    if (options.minify) {
-      try {
-        const stylesMinStart = !options.justMinified ? performance.now() : stylesStart
-
-        const minified = await transform(compiledSass.css, {
-          loader: 'css',
-          minify: true
-        })
-
-        if (this.banner) minified.code = this.banner + '\n' + minified.code
-        fs.writeFileSync(minPath, minified.code)
-        const stylesMinEnd = performance.now()
-        log({ tag: 'style', text: 'Compiled:', link: minPath, size: fileSize(minPath), time: buildTime(stylesMinStart, stylesMinEnd) })
-      } catch (err) {
-        log({ tag: 'style', error: true, text: 'Failed compiling:', link: minPath })
-        console.error(err)
-      }
-
-      if (options.justMinified) {
-        fs.unlinkSync(outfilePath)
-      }
-    } else {
-      if (pathExists(minPath)) fs.unlinkSync(minPath)
-    }
+    await minifyToFile({
+      outfilePath,
+      loader: 'css',
+      code: compiledSass.css,
+      banner: this.banner,
+      tag: 'style',
+      options,
+      startTime: options.justMinified ? stylesStart : undefined
+    })
   }
 }

package/lib/utils/helpers.js

@@ -4,6 +4,10 @@ import path from 'node:path'
 import yaml from 'yaml'
 import { convertGlobToRegex } from 'book-of-spells'
 
+export function toPosix(filePath) {
+  return path.sep === '/' ? filePath : filePath.split(path.sep).join('/')
+}
+
 export function pathExists() {
   return fs.existsSync(path.join(...arguments))
 }
@@ -36,13 +40,6 @@ export function buildStyleOutputFilePath(inputPath, outputPath) {
   return path.join(path.join(outputPath, `${name}.css`))
 }
 
-export function buildScriptOutputFilePath(inputPath, outputPath) {
-  if (pathForFile(outputPath)) return outputPath
-  const { name, ext } = path.parse(inputPath)
-  const outExt = /\.(tsx?|jsx)$/i.test(ext) ? '.js' : ext
-  return path.join(outputPath, `${name}${outExt}`)
-}
-
 export function fillBannerTemplate(template, packagesPath) {
   packagesPath = packagesPath || process.cwd()
   const packagesFilePath = path.join(packagesPath, 'package.json')
@@ -63,13 +60,14 @@ export function fillBannerTemplate(template, packagesPath) {
 
 export function buildTime(start, end) {
   const time = Math.round(end - start)
-  if (time < 1000) return `${time}ms`
-  const seconds = Math.floor(time / 1000)
+  const minutes = Math.floor(time / 60000)
+  const seconds = Math.floor(time / 1000) % 60
   const ms = time % 1000
-  if (time < 60 * 1000) return `${seconds}s ${ms}ms`
-  const minutes = Math.floor(seconds / 60)
-  const remainingSeconds = seconds % 60
-  return `${minutes}m ${remainingSeconds}s ${ms}ms`
+  const parts = []
+  if (minutes) parts.push(`${minutes}m`)
+  if (seconds) parts.push(`${seconds}s`)
+  if (ms) parts.push(`${ms}ms`)
+  return parts.join(' ') || '0ms'
 }
 
 export function fileSize(filePath) {
@@ -77,8 +75,12 @@ export function fileSize(filePath) {
   const fileSizeInBytes = stats.size
   if (fileSizeInBytes < 1000) return `${fileSizeInBytes}B`
   if (fileSizeInBytes < 1000 * 1000) return `${(fileSizeInBytes / 1000).toFixed(0)}KB`
-  if (fileSizeInBytes < 1000 * 1000 * 1000) return `${Math.floor(fileSizeInBytes / 1000 / 1000)}MB ${Math.floor((fileSizeInBytes % (1000 * 1000)) / 1000)}KB`
-  return fileSizeInBytes
+  if (fileSizeInBytes < 1000 * 1000 * 1000) {
+    const kb = Math.floor((fileSizeInBytes % (1000 * 1000)) / 1000)
+    return `${Math.floor(fileSizeInBytes / 1000 / 1000)}MB${kb ? ` ${kb}KB` : ''}`
+  }
+  const mb = Math.floor((fileSizeInBytes % (1000 * 1000 * 1000)) / 1000 / 1000)
+  return `${Math.floor(fileSizeInBytes / 1000 / 1000 / 1000)}GB${mb ? ` ${mb}MB` : ''}`
 }
 
 export function readJsonFile(filePath) {
@@ -146,10 +148,12 @@ export function copyDirectory(src, dest) {
 }
 
 export function stripDirNavSegments(filePath) {
-  return path.normalize(filePath).replace(/(\.\.\/|\.\/|\/\.\.|\.\.\\|\.\\|\\\.\.)/g, '')
+  return toPosix(path.normalize(filePath)).replace(/(\.\.\/|\.\/|\/\.\.|\.\.\\|\.\\|\\\.\.)/g, '')
 }
 
 export function pathContainsPathSegment(filePath, segment) {
+  // Watcher paths arrive with native separators, config segments with `/`
+  filePath = toPosix(filePath)
   segment = stripDirNavSegments(segment)
   if (hasMagic(segment)) {
     segment = convertGlobToRegex(segment)

package/lib/utils/log.js

@@ -8,6 +8,7 @@ const TAG_COLORS = {
   style: 'magentaBright',
   markup: 'cyanBright',
   copy: 'green',
+  image: 'greenBright',
   info: 'blue',
   error: 'redBright'
 }
@@ -18,18 +19,31 @@ const DEFAULT_COLOR = 'white'
  * @param {Object} options
  * @param {string} options.tag - Tag label (e.g. 'script', 'style', 'markup', 'reactor', 'copy', 'info')
  * @param {boolean} [options.error] - Whether this is an error message
+ * @param {boolean} [options.warn] - Whether this is a warning (does not fail the build)
  * @param {string} options.text - Main message text
  * @param {string} [options.link] - File path or URL to display underlined
  * @param {string} [options.size] - File size string
  * @param {string} [options.time] - Build time string
  */
-export default function log({ tag, error, text, link, size, time }) {
+let errorLogged = false
+
+// Build mode exits non-zero if any module reported an error, even ones
+// swallowed internally (log-and-continue). log() is the single point
+// every module error passes through, so the flag lives here.
+export function hasLoggedErrors() {
+  return errorLogged
+}
+
+export default function log({ tag, error, warn, text, link, size, time }) {
   if (tag === 'error') error = true
+  if (error) errorLogged = true
   const color = TAG_COLORS[tag] || DEFAULT_COLOR
   let msg = pstyle.paint(`{${color}.bold|[${tag}]}`)
 
   if (error) {
     msg += pstyle.paint(' {redBright.bold|[error]}')
+  } else if (warn) {
+    msg += pstyle.paint(' {yellowBright.bold|[warn]}')
   }
 
   msg += pstyle.paint(` {dim|${text}}`)

package/lib/utils/minify.js

@@ -0,0 +1,41 @@
+import { transform } from 'esbuild'
+import fs from 'node:fs'
+import { pathExists, insertMinSuffix, fileSize, buildTime } from './helpers.js'
+import log from './log.js'
+
+/**
+ * Shared post-compile minify step: writes `<name>.min<ext>` next to
+ * `outfilePath`, deletes the unminified file when `options.justMinified`,
+ * or deletes a stale `.min` file when minify is off.
+ *
+ * @param {Object} params
+ * @param {string} params.outfilePath - Compiled (unminified) output file
+ * @param {'js'|'css'} params.loader - esbuild transform loader
+ * @param {string} [params.code] - Source to minify; read from outfilePath when omitted
+ * @param {string} [params.banner] - Banner prepended to the minified code
+ * @param {string} params.tag - Log tag
+ * @param {Object} [params.options] - Entry options (`minify`, `justMinified`)
+ * @param {number} [params.startTime] - Timing start override (justMinified logs include compile time)
+ */
+export default async function minifyToFile({ outfilePath, loader, code, banner, tag, options = {}, startTime }) {
+  const minPath = insertMinSuffix(outfilePath)
+
+  if (!options.minify) {
+    if (pathExists(minPath)) fs.unlinkSync(minPath)
+    return
+  }
+
+  try {
+    const start = startTime ?? performance.now()
+    if (code == null) code = fs.readFileSync(outfilePath, 'utf-8')
+    const minified = await transform(code, { loader, minify: true })
+    if (banner) minified.code = banner + '\n' + minified.code
+    fs.writeFileSync(minPath, minified.code)
+    log({ tag, text: 'Compiled:', link: minPath, size: fileSize(minPath), time: buildTime(start, performance.now()) })
+  } catch (err) {
+    log({ tag, error: true, text: 'Failed compiling:', link: minPath })
+    console.error(err)
+  }
+
+  if (options.justMinified) fs.unlinkSync(outfilePath)
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "poops",
   "description": "Straightforward, no-bullshit bundler for the web.",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "license": "MIT",
   "type": "module",
   "main": "poops.js",
@@ -34,16 +34,20 @@
     "static-site-generator"
   ],
   "peerDependencies": {
-    "postcss": "^8.0.0"
+    "postcss": "^8.0.0",
+    "poops-images": ">=1.2.0"
   },
   "peerDependenciesMeta": {
     "postcss": {
       "optional": true
+    },
+    "poops-images": {
+      "optional": true
     }
   },
   "scripts": {
     "build": "node ./poops.js -b",
-    "lint": "eslint ./poops.js",
+    "lint": "eslint .",
     "test": "NODE_OPTIONS='--experimental-vm-modules' jest"
   },
   "dependencies": {