poops 1.1.0 → 1.2.0

package/lib/postcss.js

@@ -0,0 +1,127 @@
+import { transform } from 'esbuild'
+import fs from 'node:fs'
+import {
+  pathExists,
+  mkPath,
+  insertMinSuffix,
+  buildStyleOutputFilePath,
+  fillBannerTemplate,
+  buildTime,
+  fileSize
+} from './utils/helpers.js'
+import log from './utils/log.js'
+
+let postcss
+
+async function loadPostCSS() {
+  if (postcss) return true
+  try {
+    postcss = (await import('postcss')).default
+    return true
+  } catch (err) {
+    log({ tag: 'postcss', error: true, text: 'Missing dependency. Install: npm i -D postcss' })
+    return false
+  }
+}
+
+async function resolvePlugins(plugins) {
+  if (!plugins || !plugins.length) return []
+
+  const resolved = []
+  for (const plugin of plugins) {
+    if (typeof plugin === 'string') {
+      try {
+        const mod = await import(plugin)
+        resolved.push((mod.default || mod)())
+      } catch (err) {
+        log({ tag: 'postcss', error: true, text: `Failed to load plugin: ${plugin}` })
+        throw err
+      }
+    } else if (Array.isArray(plugin)) {
+      const [name, options] = plugin
+      try {
+        const mod = await import(name)
+        resolved.push((mod.default || mod)(options))
+      } catch (err) {
+        log({ tag: 'postcss', error: true, text: `Failed to load plugin: ${name}` })
+        throw err
+      }
+    } else {
+      resolved.push(plugin)
+    }
+  }
+  return resolved
+}
+
+export default class PostCSS {
+  constructor(config) {
+    this.config = config
+    this.banner = config.banner ? fillBannerTemplate(config.banner) : null
+  }
+
+  async compile() {
+    if (!this.config.postcss) return
+    if (!(await loadPostCSS())) return
+
+    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)
+      }
+    }
+  }
+
+  async compileEntry(infilePath, outfilePath, options = {}) {
+    outfilePath = buildStyleOutputFilePath(infilePath, outfilePath)
+
+    const input = fs.readFileSync(infilePath, 'utf-8')
+    const start = performance.now()
+
+    let result
+    try {
+      const plugins = await resolvePlugins(options.plugins)
+      const processor = postcss(plugins)
+      result = await processor.process(input, {
+        from: infilePath,
+        to: outfilePath
+      })
+    } catch (err) {
+      log({ tag: 'postcss', error: true, text: 'Failed compiling:', link: outfilePath })
+      console.error(err)
+      return
+    }
+
+    let css = result.css
+    if (this.banner) css = this.banner + '\n' + css
+    fs.writeFileSync(outfilePath, css)
+    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)
+    }
+  }
+}

package/lib/{ssg.js → reactor.js}

@@ -4,42 +4,45 @@ import {
   pathExists,
   mkPath,
   insertMinSuffix,
+  pathContainsPathSegment,
   fillBannerTemplate,
   buildTime,
   fileSize
 } from './utils/helpers.js'
 import fs from 'node:fs'
 import path from 'node:path'
-import { pathToFileURL } from 'node:url'
-import PrintStyle from './utils/print-style.js'
+import { createRequire } from 'node:module'
+import log from './utils/log.js'
 
-const pstyle = new PrintStyle()
-
-export default class SSG {
+export default class Reactor {
   constructor(config) {
     this.config = config
     this.rendered = {}
-    this.banner = fillBannerTemplate(config.banner, config.pkg)
+    this.renderedChanged = false
+    this.banner = config.banner ? fillBannerTemplate(config.banner, config.pkg) : null
   }
 
   async compile() {
-    if (!this.config.ssg) return
-    this.config.ssg = Array.isArray(this.config.ssg) ? this.config.ssg : [this.config.ssg]
+    if (!this.config.reactor) return
+    this.config.reactor = Array.isArray(this.config.reactor) ? this.config.reactor : [this.config.reactor]
+    const prevRendered = this.rendered
     this.rendered = {}
 
-    for (const entry of this.config.ssg) {
+    for (const entry of this.config.reactor) {
       if (entry.component && entry.inject && pathExists(entry.component)) {
         await this.compileEntry(entry)
       }
     }
+
+    this.renderedChanged = JSON.stringify(this.rendered) !== JSON.stringify(prevRendered)
   }
 
   async compileEntry(entry) {
     const { component, in: client, out, inject, options = {} } = entry
 
     // --- Step 1: Server-side render the component ---
-    const tmpWrapper = component.replace(/(\.[^.]+)$/, '.ssg-tmp$1')
-    const tmpBundle = component.replace(/(\.[^.]+)$/, '.ssg-bundle.cjs')
+    const tmpWrapper = component.replace(/(\.[^.]+)$/, `.reactor-tmp-${inject}$1`)
+    const tmpBundle = component.replace(/(\.[^.]+)$/, `.reactor-bundle-${inject}.cjs`)
 
     const wrapperCode = `
 import { renderToString } from 'react-dom/server';
@@ -51,7 +54,7 @@ export const html = renderToString(React.createElement(Component));
     try {
       fs.writeFileSync(tmpWrapper, wrapperCode)
 
-      const ssgStart = performance.now()
+      const renderStart = performance.now()
       await build({
         logLevel: 'error',
         entryPoints: [tmpWrapper],
@@ -63,15 +66,17 @@ export const html = renderToString(React.createElement(Component));
         nodePaths: this.config.includePaths
       })
 
-      const bundleUrl = pathToFileURL(path.resolve(tmpBundle)).href
-      const mod = await import(`${bundleUrl}?t=${Date.now()}`)
+      const bundlePath = path.resolve(tmpBundle)
+      const require = createRequire(import.meta.url)
+      delete require.cache[bundlePath]
+      const mod = require(bundlePath)
       this.rendered[inject] = mod.html
-      const ssgEnd = performance.now()
+      const renderEnd = performance.now()
 
-      console.log(`${pstyle.yellowBright + pstyle.bold}[ssg]${pstyle.reset} ${pstyle.dim}Rendered:${pstyle.reset} ${pstyle.italic + pstyle.underline}${component}${pstyle.reset} → ${pstyle.bold}${inject}${pstyle.reset} ${pstyle.green}(${buildTime(ssgStart, ssgEnd)})${pstyle.reset}`)
+      log({ tag: 'reactor', text: `Rendered: ${component} →`, link: inject, time: buildTime(renderStart, renderEnd) })
     } catch (err) {
-      console.log(`${pstyle.yellowBright + pstyle.bold}[ssg]${pstyle.reset} ${pstyle.redBright}[error]${pstyle.reset} ${pstyle.dim}Failed rendering:${pstyle.reset} ${pstyle.italic + pstyle.underline}${component}${pstyle.reset + pstyle.bell}`)
-      console.log(err)
+      log({ tag: 'reactor', error: true, text: 'Failed rendering:', link: component })
+      console.error(err)
     } finally {
       if (fs.existsSync(tmpWrapper)) fs.unlinkSync(tmpWrapper)
       if (fs.existsSync(tmpBundle)) fs.unlinkSync(tmpBundle)
@@ -115,14 +120,14 @@ export const html = renderToString(React.createElement(Component));
       try {
         await build(opts)
       } catch (err) {
-        console.log(`${pstyle.yellowBright + pstyle.bold}[ssg]${pstyle.reset} ${pstyle.redBright}[error]${pstyle.reset} ${pstyle.dim}Failed compiling client:${pstyle.reset} ${pstyle.italic + pstyle.underline}${out}${pstyle.reset + pstyle.bell}`)
-        console.log(err)
+        log({ tag: 'reactor', error: true, text: 'Failed compiling client:', link: out })
+        console.error(err)
         return
       }
       const esbuildEnd = performance.now()
 
-      if (!options.justMinified) console.log(`${pstyle.yellowBright + pstyle.bold}[ssg]${pstyle.reset} ${pstyle.dim}Compiled:${pstyle.reset} ${pstyle.italic + pstyle.underline}${out}${pstyle.reset} ${pstyle.greenBright}${fileSize(out)}${pstyle.reset} ${pstyle.green}(${buildTime(esbuildStart, esbuildEnd)})${pstyle.reset}`)
-      if (options.sourcemap) console.log(`${pstyle.yellowBright + pstyle.bold}[ssg]${pstyle.reset} ${pstyle.dim}Compiled:${pstyle.reset} ${pstyle.italic + pstyle.underline}${out}.map${pstyle.reset}`)
+      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)
@@ -136,10 +141,10 @@ export const html = renderToString(React.createElement(Component));
 
           if (this.banner) minifyResult.code = this.banner + '\n' + minifyResult.code
           fs.writeFileSync(minPath, minifyResult.code)
-          console.log(`${pstyle.yellowBright + pstyle.bold}[ssg]${pstyle.reset} ${pstyle.dim}Compiled:${pstyle.reset} ${pstyle.italic + pstyle.underline}${minPath}${pstyle.reset} ${pstyle.greenBright}${fileSize(minPath)}${pstyle.reset} ${pstyle.green}(${buildTime(terserStart, terserEnd)})${pstyle.reset}`)
+          log({ tag: 'reactor', text: 'Compiled:', link: minPath, size: fileSize(minPath), time: buildTime(terserStart, terserEnd) })
         } catch (err) {
-          console.log(`${pstyle.yellowBright + pstyle.bold}[ssg]${pstyle.reset} ${pstyle.redBright}[error]${pstyle.reset} ${pstyle.dim}Failed compiling:${pstyle.reset} ${pstyle.italic + pstyle.underline}${minPath}${pstyle.reset + pstyle.bell}`)
-          console.log(err)
+          log({ tag: 'reactor', error: true, text: 'Failed compiling:', link: minPath })
+          console.error(err)
         }
 
         if (options.justMinified) {
@@ -155,4 +160,10 @@ export const html = renderToString(React.createElement(Component));
   getRendered() {
     return this.rendered
   }
+
+  belongsToReactor(file) {
+    if (!this.config.reactor) return false
+    const entries = Array.isArray(this.config.reactor) ? this.config.reactor : [this.config.reactor]
+    return entries.some(e => e.component && pathContainsPathSegment(file, path.dirname(e.component)))
+  }
 }

package/lib/scripts.js

@@ -11,19 +11,18 @@ import {
   fileSize
 } from './utils/helpers.js'
 import fs from 'node:fs'
-import PrintStyle from './utils/print-style.js'
-
-const pstyle = new PrintStyle()
+import log from './utils/log.js'
 
 export default class Scripts {
   constructor(config) {
     this.config = config
-    this.banner = fillBannerTemplate(config.banner, config.pkg)
+    this.banner = config.banner ? fillBannerTemplate(config.banner, config.pkg) : null
   }
 
   async compile() {
     if (!this.config.scripts) return
     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)
@@ -32,7 +31,7 @@ export default class Scripts {
     }
   }
 
-  async compileEntry(infilePath, outfilePath, options = {}) {
+  async compileEntry(infilePath, outfilePath, options = {}, tag = 'script') {
     if (!Array.isArray(infilePath)) infilePath = [infilePath]
 
     const opts = {
@@ -57,7 +56,7 @@ export default class Scripts {
       opts.outdir = outfilePath
     } else {
       if (infilePath.length > 1) {
-        console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset} Cannot output multiple ${pstyle.bold + pstyle.underline}script${pstyle.reset} files to a single file. Please specify an output directory path instead.`)
+        log({ tag: 'error', text: 'Cannot output multiple script files to a single file. Please specify an output directory path instead.' })
         process.exit(1)
       }
       opts.outfile = outfilePath
@@ -78,8 +77,8 @@ export default class Scripts {
     try {
       await build(opts)
     } catch (err) {
-      console.log(`${pstyle.yellowBright + pstyle.bold}[script]${pstyle.reset} ${pstyle.redBright}[error]${pstyle.reset} ${pstyle.dim}Failed compiling:${pstyle.reset} ${pstyle.italic + pstyle.underline}${outfilePath}${pstyle.reset + pstyle.bell}`)
-      console.log(err)
+      log({ tag, error: true, text: 'Failed compiling:', link: outfilePath })
+      console.error(err)
       return
     }
     const esbuildEnd = performance.now()
@@ -88,8 +87,8 @@ export default class Scripts {
       const newOutFilePath = buildScriptOutputFilePath(entry, outfilePath)
       const minPath = insertMinSuffix(newOutFilePath)
 
-      if (!options.justMinified) console.log(`${pstyle.yellowBright + pstyle.bold}[script]${pstyle.reset} ${pstyle.dim}Compiled:${pstyle.reset} ${pstyle.italic + pstyle.underline}${newOutFilePath}${pstyle.reset} ${pstyle.greenBright}${fileSize(newOutFilePath)}${pstyle.reset} ${pstyle.green}(${buildTime(esbuildStart, esbuildEnd)})${pstyle.reset}`)
-      if (options.sourcemap) console.log(`${pstyle.yellowBright + pstyle.bold}[script]${pstyle.reset} ${pstyle.dim}Compiled:${pstyle.reset} ${pstyle.italic + pstyle.underline}${newOutFilePath}.map${pstyle.reset}`)
+      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 {
@@ -102,10 +101,10 @@ export default class Scripts {
 
           if (this.banner) minifyResult.code = this.banner + '\n' + minifyResult.code
           fs.writeFileSync(minPath, minifyResult.code)
-          console.log(`${pstyle.yellowBright + pstyle.bold}[script]${pstyle.reset} ${pstyle.dim}Compiled:${pstyle.reset} ${pstyle.italic + pstyle.underline}${minPath}${pstyle.reset} ${pstyle.greenBright}${fileSize(minPath)}${pstyle.reset} ${pstyle.green}(${buildTime(terserStart, terserEnd)})${pstyle.reset}`)
+          log({ tag, text: 'Compiled:', link: minPath, size: fileSize(minPath), time: buildTime(terserStart, terserEnd) })
         } catch (err) {
-          console.log(`${pstyle.yellowBright + pstyle.bold}[script]${pstyle.reset} ${pstyle.redBright}[error]${pstyle.reset} ${pstyle.dim}Failed compiling:${pstyle.reset} ${pstyle.italic + pstyle.underline}${minPath}${pstyle.reset + pstyle.bell}`)
-          console.log(err)
+          log({ tag, error: true, text: 'Failed compiling:', link: minPath })
+          console.error(err)
         }
 
         if (options.justMinified) {

package/lib/styles.js

@@ -11,10 +11,9 @@ import {
 } from './utils/helpers.js'
 import path from 'node:path'
 import * as sass from 'sass'
-import PrintStyle from './utils/print-style.js'
-import sassPathResolver from 'sass-path-resolver'
-
-const pstyle = new PrintStyle()
+import log from './utils/log.js'
+import { sassPathResolver } from 'sass-path-resolver'
+import { sassTokenImporter } from 'sass-token-importer'
 
 export default class Styles {
   constructor(config) {
@@ -36,10 +35,19 @@ export default class Styles {
   async compileEntry(infilePath, outfilePath, options = {}) {
     const includePaths = this.config.includePaths || []
 
+    const importers = [sassPathResolver(includePaths)]
+
+    if (options.tokenPaths) {
+      const tokenOpts = {}
+      if (options.tokenOutput) tokenOpts.output = options.tokenOutput
+      if (options.resolveAliases !== undefined) tokenOpts.resolveAliases = options.resolveAliases
+      importers.push(sassTokenImporter(options.tokenPaths, tokenOpts))
+    }
+
     const opts = {
       sourceMap: false,
       sourceMapIncludeSources: false,
-      importers: [sassPathResolver(includePaths)]
+      importers
     }
 
     if (options.sourcemap) {
@@ -54,8 +62,8 @@ export default class Styles {
     try {
       compiledSass = sass.compile(infilePath, opts)
     } catch (err) {
-      console.log(`${pstyle.magentaBright + pstyle.bold}[style]${pstyle.reset} ${pstyle.redBright}[error]${pstyle.reset} ${pstyle.dim}Failed compiling:${pstyle.reset} ${pstyle.italic + pstyle.underline}${outfilePath}${pstyle.reset + pstyle.bell}`)
-      console.log(err)
+      log({ tag: 'style', error: true, text: 'Failed compiling:', link: outfilePath })
+      console.error(err)
       return
     }
 
@@ -63,12 +71,12 @@ export default class Styles {
     if (this.banner) compiledSass.css = this.banner + '\n' + compiledSass.css
     fs.writeFileSync(outfilePath, compiledSass.css + mapsrc)
     const stylesEnd = performance.now()
-    if (!options.justMinified) console.log(`${pstyle.magentaBright + pstyle.bold}[style]${pstyle.reset} ${pstyle.dim}Compiled:${pstyle.reset} ${pstyle.italic + pstyle.underline}${outfilePath}${pstyle.reset} ${pstyle.greenBright}${fileSize(outfilePath)}${pstyle.reset} ${pstyle.green}(${buildTime(stylesStart, stylesEnd)})${pstyle.reset}`)
+    if (!options.justMinified) log({ tag: 'style', text: 'Compiled:', link: outfilePath, size: fileSize(outfilePath), time: buildTime(stylesStart, stylesEnd) })
 
     if (compiledSass.sourceMap) {
       if (this.banner) compiledSass.sourceMap.mappings = ';' + compiledSass.sourceMap.mappings
       fs.writeFileSync(`${outfilePath}.map`, JSON.stringify(compiledSass.sourceMap))
-      console.log(`${pstyle.magentaBright + pstyle.bold}[style]${pstyle.reset} ${pstyle.dim}Compiled:${pstyle.reset} ${pstyle.italic + pstyle.underline}${outfilePath}.map${pstyle.reset}`)
+      log({ tag: 'style', text: 'Compiled:', link: `${outfilePath}.map` })
     }
 
     const minPath = insertMinSuffix(outfilePath)
@@ -84,10 +92,10 @@ export default class Styles {
         if (this.banner) minified.code = this.banner + '\n' + minified.code
         fs.writeFileSync(minPath, minified.code)
         const stylesMinEnd = performance.now()
-        console.log(`${pstyle.magentaBright + pstyle.bold}[style]${pstyle.reset} ${pstyle.dim}Compiled:${pstyle.reset} ${pstyle.italic + pstyle.underline}${minPath}${pstyle.reset} ${pstyle.greenBright}${fileSize(minPath)}${pstyle.reset} ${pstyle.green}(${buildTime(stylesMinStart, stylesMinEnd)})${pstyle.reset}`)
+        log({ tag: 'style', text: 'Compiled:', link: minPath, size: fileSize(minPath), time: buildTime(stylesMinStart, stylesMinEnd) })
       } catch (err) {
-        console.log(`${pstyle.magentaBright + pstyle.bold}[style]${pstyle.reset} ${pstyle.redBright}[error]${pstyle.reset} ${pstyle.dim}Failed compiling:${pstyle.reset} ${pstyle.italic + pstyle.underline}${minPath}${pstyle.reset + pstyle.bell}`)
-        console.log(err)
+        log({ tag: 'style', error: true, text: 'Failed compiling:', link: minPath })
+        console.error(err)
       }
 
       if (options.justMinified) {

package/lib/utils/helpers.js

@@ -4,8 +4,6 @@ import path from 'node:path'
 import yaml from 'yaml'
 import { convertGlobToRegex } from 'book-of-spells'
 
-const frontMatterCache = new Map()
-
 export function pathExists() {
   return fs.existsSync(path.join(...arguments))
 }
@@ -96,60 +94,6 @@ export function readYamlFile(filePath) {
   }
 }
 
-export function parseFrontMatter(filePath) {
-  let stat
-  try {
-    stat = fs.statSync(filePath)
-  } catch (e) {
-    throw new Error(`Error stating file at ${filePath}: ${e.message}`)
-  }
-
-  const cached = frontMatterCache.get(filePath)
-  if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
-    return { frontMatter: { ...cached.value.frontMatter }, content: cached.value.content }
-  }
-
-  let content = ''
-  try {
-    content = fs.readFileSync(filePath, 'utf8')
-  } catch (e) {
-    throw new Error(`Error reading file at ${filePath}: ${e.message}`)
-  }
-
-  if (!content) {
-    throw new Error(`File at ${filePath} is empty`)
-  }
-
-  const frontMatterRegex = /^\s*---\s*[\r\n]+([\s\S]*?)\s*---\s*[\r\n]+/
-  const match = content.match(frontMatterRegex)
-
-  if (!match) {
-    const value = { frontMatter: {}, content }
-    frontMatterCache.set(filePath, { mtimeMs: stat.mtimeMs, size: stat.size, value })
-    return { frontMatter: {}, content }
-  }
-
-  let frontMatter = {}
-  try {
-    frontMatter = yaml.parse(match[1])
-  } catch (e) {
-    throw new Error(`Error parsing front matter in file at ${filePath}: ${e.message}`)
-  }
-
-  const contentWithoutFrontMatter = content.slice(match[0].length)
-  const value = { frontMatter, content: contentWithoutFrontMatter }
-  frontMatterCache.set(filePath, { mtimeMs: stat.mtimeMs, size: stat.size, value })
-  return { frontMatter: { ...frontMatter }, content: contentWithoutFrontMatter }
-}
-
-export function clearFrontMatterCache(filePath) {
-  if (!filePath) {
-    frontMatterCache.clear()
-    return
-  }
-  frontMatterCache.delete(filePath)
-}
-
 export function readDataFile(filePath) {
   if (/(\.json)$/i.test(filePath)) return readJsonFile(filePath)
   if (/(\.ya?ml)$/i.test(filePath)) return readYamlFile(filePath)

package/lib/utils/log.js

@@ -0,0 +1,64 @@
+import PrintStyle from 'printstyle'
+
+const pstyle = new PrintStyle()
+
+const TAG_COLORS = {
+  script: 'yellowBright',
+  reactor: 'yellowBright',
+  style: 'magentaBright',
+  markup: 'cyanBright',
+  copy: 'green',
+  info: 'blue',
+  error: 'redBright'
+}
+
+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 {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 }) {
+  if (tag === 'error') error = true
+  const color = TAG_COLORS[tag] || DEFAULT_COLOR
+  let msg = pstyle.paint(`{${color}.bold|[${tag}]}`)
+
+  if (error) {
+    msg += pstyle.paint(' {redBright.bold|[error]}')
+  }
+
+  msg += pstyle.paint(` {dim|${text}}`)
+
+  if (link) {
+    msg += pstyle.paint(` {italic.underline|${link}}`)
+  }
+
+  if (size) {
+    msg += pstyle.paint(` {greenBright|${size}}`)
+  }
+
+  if (time) {
+    msg += pstyle.paint(` {green|(${time})}`)
+  }
+
+  if (error) {
+    msg += pstyle.bell
+  }
+
+  if (error) {
+    console.error(msg)
+  } else {
+    console.log(msg)
+  }
+}
+
+export const bell = pstyle.bell
+
+export function styledLog(template) {
+  console.log(pstyle.paint(template))
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "poops",
   "description": "Straightforward, no-bullshit bundler for the web.",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "license": "MIT",
   "type": "module",
   "main": "poops.js",
@@ -26,40 +26,58 @@
     "javascript",
     "sass",
     "nunjucks",
+    "liquid",
     "esbuild",
     "dart-sass",
+    "tailwindcss",
     "toolchain-script",
     "static-site-generator"
   ],
+  "peerDependencies": {
+    "postcss": "^8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "postcss": {
+      "optional": true
+    }
+  },
   "scripts": {
     "build": "node ./poops.js -b",
     "lint": "eslint ./poops.js",
     "test": "NODE_OPTIONS='--experimental-vm-modules' jest"
   },
   "dependencies": {
+    "argoyle": "^1.0.0",
     "book-of-spells": "^1.0.32",
     "chokidar": "^3.5.3",
     "connect": "^3.7.0",
+    "dayjs": "^1.11.19",
     "esbuild": "^0.25.0",
     "glob": "^13.0.6",
+    "highlight.js": "^11.11.1",
+    "liquidjs": "^10.24.0",
     "livereload": "^0.9.3",
     "marked": "^9.0.3",
-    "moment": "^2.29.4",
     "nunjucks": "^3.2.4",
     "portscanner": "^2.2.0",
+    "printstyle": "^1.0.0",
     "sass": "^1.63.4",
     "sass-path-resolver": "^1.0.2",
+    "sass-token-importer": "^1.0.0",
     "serve-static": "^1.15.0",
     "yaml": "^2.3.1"
   },
   "devDependencies": {
     "@jest/globals": "^30.2.0",
+    "@tailwindcss/postcss": "^4.2.1",
     "eslint": "^9.39.3",
     "jest": "^30.2.0",
     "neostandard": "^0.12.2",
+    "postcss": "^8.5.8",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
-    "sulphuris": "^2.0.0"
+    "sulphuris": "^2.0.0",
+    "tailwindcss": "^4.2.1"
   },
   "overrides": {
     "minimatch": ">=10.2.1"