poops 1.0.1 → 1.0.2

package/lib/markups.js

@@ -0,0 +1,149 @@
+const helpers = require('./utils/helpers.js')
+const fs = require('node:fs')
+const glob = require('glob')
+const nunjucks = require('nunjucks')
+const path = require('node:path')
+const PrintStyle = require('./utils/print-style.js')
+
+const { pathExists, pathIsDirectory } = helpers
+const pstyle = new PrintStyle()
+
+class RelativeLoader extends nunjucks.Loader {
+  constructor(templatesDir, includePaths) {
+    super()
+    this.templatesDir = templatesDir
+    this.includePaths = includePaths || []
+    this.includePaths.push('_*')
+  }
+
+  getSource(name) {
+    let fullPath = name
+    if (!fs.existsSync(name)) {
+      let pattern = `**/${name}`
+      if (this.includePaths) {
+        pattern = `{${this.includePaths.join(',')}}/${pattern}`
+      }
+      fullPath = glob.sync(path.join(this.templatesDir, pattern))[0]
+    }
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`Template not found: ${name}`)
+    }
+
+    // TODO: Here we can interpret header yaml and pass it as a context, just like Jekyll does
+    const source = fs.readFileSync(fullPath, 'utf-8')
+    return { src: source, path: fullPath, noCache: true }
+  }
+
+  resolve(from, to) {
+    return path.resolve(path.dirname(from), to)
+  }
+}
+
+module.exports = class Markups {
+  constructor(config) {
+    this.config = config
+
+    if (!this.config.markup || !this.config.markup.in) return
+
+    this.nunjucksEnv = new nunjucks.Environment(new RelativeLoader(path.join(process.cwd(), config.markup.in), config.markup.includePaths), {
+      autoescape: true,
+      watch: false,
+      noCache: true
+    })
+
+    const pkgPath = path.join(process.cwd(), 'package.json')
+
+    if (fs.existsSync(pkgPath)) {
+      const pkg = require(pkgPath)
+      this.nunjucksEnv.addGlobal('package', pkg)
+    }
+
+    if (this.config.markup.site) {
+      this.nunjucksEnv.addGlobal('site', this.config.markup.site)
+    }
+
+    if (this.config.markup.data) {
+      for (const dataFile of this.config.markup.data) {
+        const data = require(path.join(process.cwd(), dataFile))
+        // TODO: should support YAML too. There should be a way to define the data file per template through front matter
+        this.nunjucksEnv.addGlobal(path.basename(dataFile, path.extname(dataFile)).replace(/[.\-\s]/g, '_'), data)
+      }
+    }
+
+    this.payload = {} // TODO: still not used. This is where we can store data from data files. Can be used to pass front matter data or even a way to pass data from files to templates
+
+    if (!this.config.markup.out) {
+      this.config.markup.out = process.cwd()
+    }
+  }
+
+  generateMarkupGlobPattern(excludes) {
+    let markupDefaultExcludes = ['node_modules', '.git', '.svn', '.hg']
+
+    if (excludes) {
+      markupDefaultExcludes.push(...excludes)
+    }
+
+    if (this.config.includePaths) {
+      markupDefaultExcludes.push(...this.config.includePaths)
+    }
+
+    markupDefaultExcludes.push('_*')
+
+    markupDefaultExcludes = [...new Set(markupDefaultExcludes)] // Remove duplicates
+
+    return `!(${markupDefaultExcludes.join('|')})/**/*.+(html|njk)`
+  }
+
+  compileEntry(templateName, context) {
+    const env = this.nunjucksEnv
+    return new Promise((resolve, reject) => {
+      env.getTemplate(templateName).render(context, (error, result) => {
+        if (!error) {
+          resolve(result)
+        } else {
+          reject(error)
+        }
+      })
+    })
+  }
+
+  compile() {
+    // TODO: should support multiple markup paths, for loop here!
+    if (!this.config.markup || !this.config.markup.in) return
+
+    const markupIn = path.join(process.cwd(), this.config.markup.in)
+
+    if (!pathExists(markupIn)) {
+      console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset} Markup path does not exist: ${pstyle.dim}${markupIn}${pstyle.reset}`)
+      return
+    }
+
+    if (pathIsDirectory(markupIn)) {
+      const markupFiles = [...glob.sync(path.join(markupIn, this.generateMarkupGlobPattern(this.config.markup.includePaths))), ...glob.sync(path.join(markupIn, '*.+(html|njk)'))]
+      const compilePromises = []
+      markupFiles.forEach((file) => {
+        const markupOut = path.join(process.cwd(), path.relative(this.config.markup.in, file))
+        const markupOutDir = path.dirname(markupOut)
+
+        if (!pathExists(markupOutDir)) {
+          fs.mkdirSync(markupOutDir, { recursive: true })
+        }
+
+        const compilePromise = this.compileEntry(file, this.payload).then((result) => {
+          fs.writeFileSync(markupOut, result)
+        })
+        compilePromises.push(compilePromise)
+      })
+
+      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}`)
+      })
+    } else {
+      this.compileEntry(markupIn, this.pkg).then((result) => {
+        fs.writeFileSync(path.join(process.cwd(), this.config.markup.out, path.basename(markupIn)), 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}`)
+      })
+    }
+  }
+}

package/lib/scripts.js

@@ -0,0 +1,116 @@
+const { build } = require('esbuild')
+const deepmerge = require('deepmerge')
+const helpers = require('./utils/helpers.js')
+const fs = require('node:fs')
+const PrintStyle = require('./utils/print-style.js')
+const Terser = require('terser')
+
+const {
+  pathExists,
+  mkPath,
+  pathForFile,
+  insertMinSuffix,
+  buildScriptOutputFilePath,
+  fillBannerTemplate,
+  buildTime,
+  fileSize
+} = helpers
+
+const pstyle = new PrintStyle()
+
+module.exports = class Scripts {
+  constructor(config) {
+    this.config = config
+    this.banner = fillBannerTemplate(config.banner, config.pkg)
+  }
+
+  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)
+        this.compileEntry(scriptEntry.in, scriptEntry.out, scriptEntry.options)
+      }
+    }
+  }
+
+  compileEntry(infilePath, outfilePath, options = {}) {
+    if (!Array.isArray(infilePath)) infilePath = [infilePath]
+
+    const opts = {
+      logLevel: 'error',
+      entryPoints: infilePath,
+      bundle: true,
+      sourcemap: false,
+      minify: false,
+      format: 'iife',
+      target: 'es2019',
+      nodePaths: this.config.includePaths // Resolve `includePaths`
+    }
+
+    const terserOpts = {
+      mangle: false
+    }
+
+    if (this.banner) {
+      opts.banner = {
+        js: this.banner,
+        css: this.banner
+      }
+    }
+
+    if (!pathForFile(outfilePath)) {
+      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.`)
+        process.exit(1)
+      }
+      opts.outfile = outfilePath
+    }
+
+    if (options.format) opts.format = options.format
+    if (options.target) opts.target = options.target
+    if (options.nodePaths) opts.nodePaths = [...new Set([...opts.nodePaths, ...options.nodePaths])]
+    if (options.sourcemap) opts.sourcemap = options.sourcemap
+
+    if (options.mangle) terserOpts.mangle = options.mangle
+
+    delete options.mangle
+    deepmerge(opts, options) // ability to pass other esbuild options `node_modules/esbuild/lib/main.d.ts`
+
+    // TODO: Actually loop the build process for each entry point!!!
+    const esbuildStart = performance.now()
+    build(opts).then(() => {
+      const esbuildEnd = performance.now()
+      for (const entry of infilePath) {
+        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.minify) {
+          const terserStart = performance.now()
+          Terser.minify(fs.readFileSync(newOutFilePath, 'utf-8'), { mangle: terserOpts.mangle }).then((result) => {
+            if (result.error) {
+              console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset} Error occurred during JS minification: ${pstyle.dim}${result.error}${pstyle.reset}`)
+            } else {
+              if (this.banner) result.code = this.banner + '\n' + result.code
+              fs.writeFileSync(minPath, result.code)
+              const terserEnd = performance.now()
+              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}`)
+            }
+          })
+
+          if (options.justMinified) {
+            fs.unlinkSync(newOutFilePath)
+          }
+        } else {
+          fs.unlinkSync(minPath)
+        }
+      }
+    })
+  }
+}

package/lib/styles.js

@@ -0,0 +1,140 @@
+const autoprefixer = require('autoprefixer')
+const cssnano = require('cssnano')
+const fs = require('node:fs')
+const helpers = require('./utils/helpers.js')
+const path = require('node:path')
+const { pathToFileURL } = require('node:url')
+const postcss = require('postcss')
+const sass = require('sass')
+const PrintStyle = require('./utils/print-style.js')
+
+const {
+  pathExists,
+  pathIsDirectory,
+  mkPath,
+  insertMinSuffix,
+  buildStyleOutputFilePath,
+  fillBannerTemplate,
+  buildTime,
+  fileSize
+} = helpers
+
+const pstyle = new PrintStyle()
+
+function tryToFindFile(filePath, extensions) {
+  const fileExt = extensions.find(ext => fs.existsSync(`${filePath}.${ext}`))
+  if (fileExt) {
+    return `${filePath}.${fileExt}`
+  }
+  return null
+}
+
+function sassPathResolver(url, resolvePath) {
+  if (fs.existsSync(url)) return new URL(url)
+  const resolvedPath = pathToFileURL(resolvePath)
+  if (!fs.existsSync(resolvedPath.pathname)) return null
+  const importPath = path.relative(process.cwd(), path.join(resolvedPath.pathname, url))
+
+  if (!fs.existsSync(importPath)) {
+    const correctFile = tryToFindFile(importPath, ['sass', 'scss', 'css'])
+    if (correctFile) return new URL(correctFile, resolvedPath)
+  }
+
+  if (pathIsDirectory(importPath) && !pathExists(importPath, 'index.sass') && !pathExists(importPath, 'index.scss')) {
+    const correctFile = tryToFindFile(importPath, ['sass', 'scss', 'css'])
+    if (correctFile) return new URL(correctFile, resolvedPath)
+
+    if (!pathExists(importPath, 'package.json')) return null
+
+    const pkg = require(path.join(importPath, 'package.json'))
+
+    if (pkg.sass) return new URL(path.join(importPath, pkg.sass), resolvedPath)
+    if (pkg.css) return new URL(path.join(importPath, pkg.css), resolvedPath)
+
+    const basename = path.basename(pkg.main)
+    if (pkg.main && /(\.sass|\.scss|\.css)$/i.test(basename)) return new URL(path.join(importPath, pkg.main), resolvedPath)
+    return null
+  }
+
+  return new URL(importPath, resolvedPath)
+}
+
+module.exports = class Styles {
+  constructor(config) {
+    this.config = config
+    this.banner = config.banner ? fillBannerTemplate(config.banner) : null
+  }
+
+  compile() {
+    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)
+        this.compileEntry(styleEntry.in, styleEntry.out, styleEntry.options)
+      }
+    }
+  }
+
+  compileEntry(infilePath, outfilePath, options = {}) {
+    const includePaths = this.config.includePaths || []
+
+    const opts = {
+      sourceMap: false,
+      sourceMapIncludeSources: false,
+      importers: [{
+        // Resolve `includePaths`.
+        findFileUrl(url) {
+          for (const includePath of includePaths) {
+            const resolvedPath = sassPathResolver(url, includePath)
+            if (resolvedPath) return resolvedPath
+          }
+          return null
+        }
+      }]
+    }
+
+    if (options.sourcemap) {
+      opts.sourceMap = options.sourcemap
+      opts.sourceMapIncludeSources = options.sourcemap
+    }
+
+    outfilePath = buildStyleOutputFilePath(infilePath, outfilePath, options)
+
+    const cssStart = performance.now()
+    const compiledSass = sass.compile(infilePath, opts)
+    const mapsrc = options.sourcemap ? `\n/*# sourceMappingURL=${path.basename(outfilePath)}.map */` : ''
+    if (this.banner) compiledSass.css = this.banner + '\n' + compiledSass.css
+    fs.writeFileSync(outfilePath, compiledSass.css + mapsrc)
+    const cssEnd = 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(cssStart, cssEnd)})${pstyle.reset}`)
+
+    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}`)
+    }
+
+    const cssMinStart = performance.now()
+    const minPath = insertMinSuffix(outfilePath)
+    if (options.minify) {
+      postcss([autoprefixer, cssnano]).process(compiledSass.css, {
+        from: outfilePath,
+        to: minPath
+      }).then(result => {
+        if (this.banner) result.css = this.banner + '\n' + result.css
+        fs.writeFileSync(minPath, result.css)
+        const cssMinEnd = 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(cssMinStart, cssMinEnd)})${pstyle.reset}`)
+      }).catch((error) => {
+        console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset} Error occurred during CSS minification: ${pstyle.dim}${error}${pstyle.reset}`)
+      })
+
+      if (options.justMinified) {
+        fs.unlinkSync(outfilePath)
+      }
+    } else {
+      fs.unlinkSync(minPath)
+    }
+  }
+}

package/lib/utils/helpers.js

@@ -0,0 +1,81 @@
+const fs = require('node:fs')
+const path = require('node:path')
+
+function pathExists() {
+  return fs.existsSync(path.join(...arguments))
+}
+
+function pathIsDirectory() {
+  return fs.lstatSync(path.join(...arguments)).isDirectory()
+}
+
+function mkPath(filePath) {
+  const dirPath = path.dirname(filePath)
+  if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true })
+}
+
+function pathForFile(filePath) {
+  return /\./.test(path.basename(filePath))
+}
+
+function insertMinSuffix(filePath) {
+  const { name, ext } = path.parse(filePath)
+  return path.join(path.dirname(filePath), `${name}.min${ext}`)
+}
+
+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) {
+  if (pathForFile(outputPath)) return outputPath
+  const { name, ext } = path.parse(inputPath)
+  return path.join(path.join(outputPath, `${name}${ext.replace('t', 'j')}`))
+}
+
+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 { name, version, homepage, description, license, author } = pkg
+  const year = new Date().getFullYear()
+
+  return template
+    .replace(/{{\s?name\s?}}/g, name)
+    .replace(/{{\s?version\s?}}/g, version)
+    .replace(/{{\s?homepage\s?}}/g, homepage)
+    .replace(/{{\s?description\s?}}/g, description)
+    .replace(/{{\s?author\s?}}/g, author)
+    .replace(/{{\s?license\s?}}/g, license)
+    .replace(/{{\s?year\s?}}/g, year)
+}
+
+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`
+}
+
+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`
+  return fileSizeInBytes
+}
+
+exports.pathExists = pathExists
+exports.pathIsDirectory = pathIsDirectory
+exports.mkPath = mkPath
+exports.pathForFile = pathForFile
+exports.insertMinSuffix = insertMinSuffix
+exports.buildStyleOutputFilePath = buildStyleOutputFilePath
+exports.buildScriptOutputFilePath = buildScriptOutputFilePath
+exports.fillBannerTemplate = fillBannerTemplate
+exports.buildTime = buildTime
+exports.fileSize = fileSize

package/lib/utils/print-style.js

@@ -0,0 +1,72 @@
+module.exports = class PrintStyle {
+  reset = '\x1b[0m'
+  bold = '\x1b[1m'
+  dim = '\x1b[2m'
+  italic = '\x1b[3m'
+  underline = '\x1b[4m'
+  blink = '\x1b[5m'
+  inverse = '\x1b[7m'
+  hidden = '\x1b[8m'
+  strikethrough = '\x1b[9m'
+  black = '\x1b[30m'
+  red = '\x1b[31m'
+  redBright = '\x1b[91m'
+  green = '\x1b[32m'
+  greenBright = '\x1b[92m'
+  yellow = '\x1b[33m'
+  yellowBright = '\x1b[93m'
+  blue = '\x1b[34m'
+  blueBright = '\x1b[94m'
+  magenta = '\x1b[35m'
+  magentaBright = '\x1b[95m'
+  cyan = '\x1b[36m'
+  cyanBright = '\x1b[96m'
+  white = '\x1b[37m'
+  whiteBright = '\x1b[97m'
+  gray = '\x1b[90m'
+  bgBlack = '\x1b[40m'
+  bgRed = '\x1b[41m'
+  bgRedBright = '\x1b[101m'
+  bgGreen = '\x1b[42m'
+  bgGreenBright = '\x1b[102m'
+  bgYellow = '\x1b[43m'
+  bgYellowBright = '\x1b[103m'
+  bgBlue = '\x1b[44m'
+  bgBlueBright = '\x1b[104m'
+  bgMagenta = '\x1b[45m'
+  bgMagentaBright = '\x1b[105m'
+  bgCyan = '\x1b[46m'
+  bgCyanBright = '\x1b[106m'
+  bgWhite = '\x1b[47m'
+  bgWhiteBright = '\x1b[107m'
+  bgGray = '\x1b[100m'
+  bell = '\x07'
+
+  hexToRgb(hex) {
+    const sanitizedHex = hex.replace('#', '')
+    const red = parseInt(sanitizedHex.substring(0, 2), 16)
+    const green = parseInt(sanitizedHex.substring(2, 4), 16)
+    const blue = parseInt(sanitizedHex.substring(4, 6), 16)
+
+    return [red, green, blue]
+  }
+
+  terminalColorIndex(red, green, blue) {
+    return 16 +
+      Math.round(red / 255 * 5) * 36 +
+      Math.round(green / 255 * 5) * 6 +
+      Math.round(blue / 255 * 5)
+  }
+
+  color(hex) {
+    const [red, green, blue] = this.hexToRgb(hex)
+
+    return `\x1b[38;5;${this.terminalColorIndex(red, green, blue)}m`
+  }
+
+  background(hex) {
+    const [red, green, blue] = this.hexToRgb(hex)
+
+    return `\x1b[48;5;${this.terminalColorIndex(red, green, blue)}m`
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "poops",
   "description": "A super simple bundler for simple web projects.",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "license": "MIT",
   "main": "poops.js",
   "repository": "https://github.com/stamat/poops.git",
@@ -27,7 +27,9 @@
     "cssnano": "^6.0.1",
     "deepmerge": "^4.3.1",
     "esbuild": "^0.18.4",
+    "glob": "^10.3.1",
     "livereload": "^0.9.3",
+    "nunjucks": "^3.2.4",
     "postcss": "^8.4.24",
     "sass": "^1.63.4",
     "serve-static": "^1.15.0",
@@ -36,7 +38,7 @@
   "devDependencies": {
     "eslint": "^8.42.0",
     "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-n": "^16.0.0",
     "eslint-plugin-promise": "^6.1.1",
     "sulphuris": "^1.0.5"