poops 1.0.20 → 1.2.0

package/lib/utils/helpers.js

@@ -1,51 +1,53 @@
-const fs = require('node:fs')
-const glob = require('glob')
-const path = require('node:path')
-const frontMatterCache = new Map()
+import fs from 'node:fs'
+import { hasMagic } from 'glob'
+import path from 'node:path'
+import yaml from 'yaml'
+import { convertGlobToRegex } from 'book-of-spells'
 
-function pathExists() {
+export function pathExists() {
   return fs.existsSync(path.join(...arguments))
 }
 
-function pathIsDirectory() {
+export function pathIsDirectory() {
   return fs.lstatSync(path.join(...arguments)).isDirectory()
 }
 
-function mkDir(dirPath) {
+export function mkDir(dirPath) {
   if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true })
 }
 
-function mkPath(filePath) {
+export function mkPath(filePath) {
   const dirPath = path.dirname(filePath)
   mkDir(dirPath)
 }
 
-function pathForFile(filePath) {
-  return /\./.test(path.basename(filePath))
+export function pathForFile(filePath) {
+  return path.extname(filePath) !== ''
 }
 
-function insertMinSuffix(filePath) {
+export function insertMinSuffix(filePath) {
   const { name, ext } = path.parse(filePath)
   return path.join(path.dirname(filePath), `${name}.min${ext}`)
 }
 
-function buildStyleOutputFilePath(inputPath, outputPath) {
+export function buildStyleOutputFilePath(inputPath, outputPath) {
   if (pathForFile(outputPath)) return outputPath
   const { name } = path.parse(inputPath)
   return path.join(path.join(outputPath, `${name}.css`))
 }
 
-function buildScriptOutputFilePath(inputPath, outputPath) {
+export function buildScriptOutputFilePath(inputPath, outputPath) {
   if (pathForFile(outputPath)) return outputPath
   const { name, ext } = path.parse(inputPath)
-  return path.join(path.join(outputPath, `${name}${ext.replace('t', 'j')}`))
+  const outExt = /\.(tsx?|jsx)$/i.test(ext) ? '.js' : ext
+  return path.join(outputPath, `${name}${outExt}`)
 }
 
-function fillBannerTemplate(template, packagesPath) {
+export function fillBannerTemplate(template, packagesPath) {
   packagesPath = packagesPath || process.cwd()
   const packagesFilePath = path.join(packagesPath, 'package.json')
   if (!pathExists(packagesFilePath)) return template
-  const pkg = require(packagesFilePath)
+  const pkg = JSON.parse(fs.readFileSync(packagesFilePath, 'utf-8'))
   const { name, version, homepage, description, license, author } = pkg
   const year = new Date().getFullYear()
 
@@ -59,96 +61,46 @@ function fillBannerTemplate(template, packagesPath) {
     .replace(/{{\s?year\s?}}/g, year)
 }
 
-function buildTime(start, end) {
+export function buildTime(start, end) {
   const time = Math.round(end - start)
   if (time < 1000) return `${time}ms`
-  if (time < 60 * 1000) return `${(time / 1000).toFixed(0)}s ${time % 1000}ms`
-  return `${(time / 1000 / 60).toFixed(0)}m ${((time / 1000) % 60).toFixed(0)}s ${time % 1000}ms`
+  const seconds = Math.floor(time / 1000)
+  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`
 }
 
-function fileSize(filePath) {
+export function fileSize(filePath) {
   const stats = fs.statSync(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 `${(fileSizeInBytes / 1000 / 1000).toFixed(0)}MB ${fileSizeInBytes % (1000 * 1000)}KB`
+  if (fileSizeInBytes < 1000 * 1000 * 1000) return `${Math.floor(fileSizeInBytes / 1000 / 1000)}MB ${Math.floor((fileSizeInBytes % (1000 * 1000)) / 1000)}KB`
   return fileSizeInBytes
 }
 
-function readJsonFile(filePath) {
+export function readJsonFile(filePath) {
   return JSON.parse(fs.readFileSync(filePath, 'utf8'))
 }
 
-function readYamlFile(filePath) {
+export function readYamlFile(filePath) {
   try {
-    return require('yaml').parse(fs.readFileSync(filePath, 'utf8'))
+    return yaml.parse(fs.readFileSync(filePath, 'utf8'))
   } catch (e) {
     console.error(`Error reading YAML file at ${filePath}:`, e)
     return null
   }
 }
 
-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 = require('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 }
-}
-
-function clearFrontMatterCache(filePath) {
-  if (!filePath) {
-    frontMatterCache.clear()
-    return
-  }
-  frontMatterCache.delete(filePath)
-}
-
-function readDataFile(filePath) {
+export function readDataFile(filePath) {
   if (/(\.json)$/i.test(filePath)) return readJsonFile(filePath)
   if (/(\.ya?ml)$/i.test(filePath)) return readYamlFile(filePath)
   return fs.readFileSync(filePath, 'utf8')
 }
 
-function deleteDirectoryContents(directory) {
+export function deleteDirectoryContents(directory) {
   if (!pathExists(directory)) return
   const files = fs.readdirSync(directory)
 
@@ -157,21 +109,19 @@ function deleteDirectoryContents(directory) {
     const stat = fs.statSync(filePath)
 
     if (stat.isDirectory()) {
-      deleteDirectoryContents(filePath)
-      fs.rmdirSync(filePath)
+      fs.rmSync(filePath, { recursive: true })
     } else {
       fs.unlinkSync(filePath)
     }
   }
 }
 
-function deleteDirectory(directory) {
+export function deleteDirectory(directory) {
   if (!pathExists(directory)) return
-  deleteDirectoryContents(directory)
-  fs.rmdirSync(directory)
+  fs.rmSync(directory, { recursive: true })
 }
 
-function copyDirectory(src, dest) {
+export function copyDirectory(src, dest) {
   if (!pathExists(src)) return
 
   if (!pathIsDirectory(src)) {
@@ -195,80 +145,13 @@ function copyDirectory(src, dest) {
   }
 }
 
-function convertGlobToRegex(glob) {
-  let regexString = ''
-  const charMap = {
-    '*': '[^\\/\\\\]*',
-    '?': '[^\\/\\\\]',
-    '!': '^',
-    '{': '(',
-    '}': ')',
-    ',': '|',
-    '.': '\\.',
-    '-': '\\-',
-    // eslint-disable-next-line quote-props
-    '$': '\\$',
-    '+': '\\+',
-    '/': '\\/',
-    '\\': '\\\\'
-  }
-  let insideSquareBrackets = false
-  let insideCurlyBraces = false
-
-  for (let i = 0; i < glob.length; i++) {
-    const char = glob[i]
-    // eslint-disable-next-line no-prototype-builtins
-    if (charMap.hasOwnProperty(char)) {
-      let currentChar = charMap[char]
-      switch (char) {
-        case '{':
-          insideCurlyBraces = true
-          break
-        case '}':
-          insideCurlyBraces = false
-          break
-        case '!':
-          if (!insideSquareBrackets) currentChar = '\\!' // Escape '!' outside square brackets
-          break
-        case ',':
-          if (!insideCurlyBraces) currentChar = '\\,' // Escape ',' outside curly braces
-          break
-        case '-':
-          if (insideSquareBrackets) currentChar = char // Don't escape '-' inside square brackets
-          break
-      }
-      regexString += currentChar
-    } else {
-      switch (char) {
-        case '[':
-          insideSquareBrackets = true
-          break
-        case ']':
-          insideSquareBrackets = false
-          break
-      }
-      regexString += char
-    }
-  }
-
-  let re = null
-
-  try {
-    re = new RegExp(regexString)
-  } catch (e) {
-    // Invalid regex
-  }
-
-  return re
-}
-
-function removeDirNavWildcards(filePath) {
+export function stripDirNavSegments(filePath) {
   return path.normalize(filePath).replace(/(\.\.\/|\.\/|\/\.\.|\.\.\\|\.\\|\\\.\.)/g, '')
 }
 
-function pathContainsPathSegment(filePath, segment) {
-  segment = removeDirNavWildcards(segment)
-  if (glob.hasMagic(segment)) {
+export function pathContainsPathSegment(filePath, segment) {
+  segment = stripDirNavSegments(segment)
+  if (hasMagic(segment)) {
     segment = convertGlobToRegex(segment)
     if (!segment) return false
     return segment.test(filePath)
@@ -277,7 +160,7 @@ function pathContainsPathSegment(filePath, segment) {
   }
 }
 
-function doesFileBelongToPath(filePath, configPaths) {
+export function doesFileBelongToPath(filePath, configPaths) {
   if (!configPaths) return false
   if (!Array.isArray(configPaths)) configPaths = [configPaths]
   for (const configPath of configPaths) {
@@ -294,26 +177,3 @@ function doesFileBelongToPath(filePath, configPaths) {
   }
   return false
 }
-
-module.exports = {
-  pathExists,
-  pathIsDirectory,
-  mkDir,
-  mkPath,
-  pathForFile,
-  insertMinSuffix,
-  buildStyleOutputFilePath,
-  buildScriptOutputFilePath,
-  fillBannerTemplate,
-  buildTime,
-  fileSize,
-  readJsonFile,
-  readYamlFile,
-  readDataFile,
-  deleteDirectoryContents,
-  deleteDirectory,
-  copyDirectory,
-  doesFileBelongToPath,
-  parseFrontMatter,
-  clearFrontMatterCache
-}

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,8 +1,9 @@
 {
   "name": "poops",
   "description": "Straightforward, no-bullshit bundler for the web.",
-  "version": "1.0.20",
+  "version": "1.2.0",
   "license": "MIT",
+  "type": "module",
   "main": "poops.js",
   "repository": {
     "type": "git",
@@ -14,7 +15,8 @@
   },
   "files": [
     "poops.js",
-    "lib/"
+    "lib/",
+    "!lib/**/__tests__/"
   ],
   "author": "Stamat <@stamat> (http://stamat.info)",
   "homepage": "https://github.com/stamat/poops",
@@ -24,36 +26,60 @@
     "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"
+    "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",
-    "deepmerge": "^4.3.1",
+    "dayjs": "^1.11.19",
     "esbuild": "^0.25.0",
-    "glob": "^10.3.1",
+    "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": {
-    "eslint": "^8.42.0",
-    "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-n": "^16.0.0",
-    "eslint-plugin-promise": "^6.1.1",
-    "sulphuris": "^2.0.0"
+    "@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",
+    "tailwindcss": "^4.2.1"
+  },
+  "overrides": {
+    "minimatch": ">=10.2.1"
   }
 }