@sequencemedia/gulp-cli 1.0.0

package/lib/config/load-files.mjs

@@ -0,0 +1,50 @@
+import copyProps from 'copy-props'
+import {
+  join,
+  extname,
+  resolve,
+  dirname
+} from 'node:path'
+
+function getConfig (module) {
+  if (Reflect.has(module, 'default')) return Reflect.get(module, 'default')
+  return module
+}
+
+export default async function loadConfigFiles (configFiles = {}, configFileOrder = []) {
+  const config = {}
+
+  const keyList = (
+    configFileOrder
+      .filter((key) => configFiles[key])
+  )
+
+  while (keyList.length) {
+    const key = keyList.shift()
+    const filePath = configFiles[key]
+
+    try {
+      const module = (
+        extname(filePath) === '.json'
+          ? await import(resolve(join(process.cwd(), filePath)), { assert: { type: 'json' } })
+          : await import(resolve(join(process.cwd(), filePath)))
+      )
+
+      copyProps(getConfig(module), config, ({ keyChain, value }) => {
+        if (keyChain === 'flags.gulpfile') {
+          return resolve(dirname(filePath), value)
+        }
+
+        return value
+      })
+    } catch (e) {
+      const {
+        code
+      } = e
+
+      if (code !== 'ERR_MODULE_NOT_FOUND') console.error(e)
+    }
+  }
+
+  return config
+}

package/lib/exit.mjs

@@ -0,0 +1,8 @@
+// Fix stdout truncation on windows
+export default function exit (code) {
+  if (process.platform === 'win32' && process.stdout.writableLength) {
+    process.stdout.once('drain', () => { process.exit(code) })
+    return
+  }
+  process.exit(code)
+}

package/lib/format-error.mjs

@@ -0,0 +1,19 @@
+// Format orchestrator errors
+export default function formatError (e) {
+  if (!e.error) {
+    return e.message
+  }
+
+  // PluginError
+  if (typeof e.error.showStack === 'boolean') {
+    return e.error.toString()
+  }
+
+  // Normal error
+  if (e.error.stack) {
+    return e.error.stack
+  }
+
+  // Unknown (string, number, etc.)
+  return new Error(String(e.error)).stack
+}

package/lib/get-blacklist.mjs

@@ -0,0 +1,7 @@
+const URL = 'https://raw.githubusercontent.com/gulpjs/plugins/master/src/blackList.json'
+
+export default async function getBlacklist () {
+  const response = await fetch(URL)
+
+  return response.json()
+}

package/lib/get-completion.mjs

@@ -0,0 +1,21 @@
+import path from 'node:path'
+
+import {
+  readFile
+} from 'node:fs/promises'
+
+export default async function getCompletion (completionType) {
+  if (typeof completionType !== 'string') {
+    throw new Error('Completion type not provided')
+  }
+
+  try {
+    const filePath = path.join('./completion', completionType)
+    const fileData = await readFile(filePath, 'utf8')
+    console.log(fileData.toString().trim())
+    process.exit(0)
+  } catch (e) {
+    console.error(`echo "Completion type "${completionType}" not found"`)
+    process.exit(5)
+  }
+}

package/lib/get-duplicate.mjs

@@ -0,0 +1,80 @@
+const DEFAULT_NODE_FACTORY = {
+  topNode: getDuplicateOf,
+  taskNode: getDuplicateOf,
+  childNode: getDuplicateOf
+}
+
+function getDuplicateOf (node) {
+  return Object.fromEntries(Object.entries(node))
+}
+
+function hasCompactTasks ({ compactTasks = false }) {
+  return String(compactTasks) === 'true'
+}
+
+function getTasksDepth ({ tasksDepth }) {
+  return (
+    typeof tasksDepth === 'number' && !isNaN(tasksDepth)
+      ? Math.max(1, tasksDepth)
+      : null
+  )
+}
+
+function nonRecursiveDuplicateNode (child, parent, nodeFactory) {
+  const dupe = nodeFactory.childNode(child)
+  dupe.nodes = []
+
+  parent.nodes.push(dupe)
+
+  if (child.branch) {
+    duplicateNodesFor(child, nonRecursiveDuplicateNode, dupe, nodeFactory)
+  }
+}
+
+function recursiveDuplicateNode (child, parent, maximumDepth, currentDepth, nodeFactory) {
+  const dupe = nodeFactory.childNode(child)
+  dupe.nodes = []
+
+  parent.nodes.push(dupe)
+
+  if (!maximumDepth || maximumDepth > currentDepth) {
+    duplicateNodesFor(child, recursiveDuplicateNode, dupe, maximumDepth, currentDepth + 1, nodeFactory)
+  }
+}
+
+function duplicateNodesFor ({ nodes }, duplicate, ...args) {
+  if (Array.isArray(nodes)) {
+    nodes
+      .forEach((node) => {
+        duplicate(node, ...args)
+      })
+  }
+}
+
+function duplicateNode (node, tree, cliProps, nodeFactory = DEFAULT_NODE_FACTORY) {
+  const dupe = nodeFactory.taskNode(node)
+  dupe.nodes = []
+
+  tree.nodes.push(dupe)
+
+  if (hasCompactTasks(cliProps)) {
+    duplicateNodesFor(node, nonRecursiveDuplicateNode, dupe, nodeFactory)
+  } else {
+    const maximumDepth = getTasksDepth(cliProps)
+
+    if (!maximumDepth || maximumDepth > 1) {
+      duplicateNodesFor(node, recursiveDuplicateNode, dupe, maximumDepth, 2, nodeFactory)
+    }
+  }
+}
+
+function duplicateTree (tree = {}, cliProps = {}, nodeFactory = DEFAULT_NODE_FACTORY) {
+  const dupe = nodeFactory.topNode(tree)
+  dupe.nodes = []
+
+  duplicateNodesFor(tree, duplicateNode, dupe, cliProps, nodeFactory)
+
+  return dupe
+}
+
+export default duplicateTree

package/lib/get-package-blacklist.mjs

@@ -0,0 +1,23 @@
+import matchdep from 'matchdep'
+
+/**
+ * Given a collection of plugin names verifies this collection against
+ * the blacklist. Returns an object with:
+ * [plugin name]=>[blacklisting reason]
+ * or an empty object if none of the dependencies to check are blacklisted.
+ *
+ * @param packageJson - The package JSON
+ * @param blacklistJson - The blacklist JSON
+ */
+function getPackageBlacklist (packageJson, blacklistJson) {
+  return (
+    matchdep
+      .filterAll(Object.keys(blacklistJson), packageJson)
+      .reduce((blacklist, dependency) => {
+        blacklist[dependency] = blacklistJson[dependency]
+        return blacklist
+      }, {})
+  )
+}
+
+export default getPackageBlacklist

package/lib/get-process-title.mjs

@@ -0,0 +1,3 @@
+export default function getProcessTitle (argv = []) {
+  return ['gulp'].concat(argv).join(' ').trim()
+}

package/lib/get-task.mjs

@@ -0,0 +1,41 @@
+import isObject from 'isobject'
+
+function isString (value) {
+  return typeof value === 'string'
+}
+
+function isFunction (value) {
+  return value instanceof Function
+}
+
+function getDescription (task = {}) {
+  if (isString(task.description)) {
+    return task.description
+  }
+
+  if (isFunction(task.unwrap)) {
+    return getDescription(task.unwrap())
+  }
+}
+
+function getFlags (task = {}) {
+  if (isObject(task.flags)) {
+    return task.flags
+  }
+
+  if (isFunction(task.unwrap)) {
+    return getFlags(task.unwrap())
+  }
+}
+
+function getTask (gulp) {
+  return function getTaskFor (name) {
+    const task = gulp.task(name)
+    return {
+      description: getDescription(task),
+      flags: getFlags(task)
+    }
+  }
+}
+
+export default getTask

package/lib/index.mjs

@@ -0,0 +1,59 @@
+import stdout from 'mute-stdout'
+
+import listenForGulpEvents from './log/listen-for-gulp-events.mjs'
+import listenForSyncEvents from './log/listen-for-sync-events.mjs'
+import registerGulpTasks from './register-gulp-tasks.mjs'
+
+import runGulpTasks from './run-gulp-tasks.mjs'
+
+function getImportFromModulePath (params) {
+  const {
+    envProps: {
+      modulePath
+    }
+  } = params
+
+  return (
+    import(modulePath)
+      .then(({ default: gulp }) => Object.assign(params, { gulp }))
+  )
+}
+
+function getImportFromConfigPath (params) {
+  const {
+    envProps: {
+      configPath
+    }
+  } = params
+
+  return (
+    import(configPath)
+      .then((tasks) => Object.assign(params, { tasks }))
+  )
+}
+
+function isSilent (cliProps) {
+  return (cliProps.tasksList || cliProps.tasks || cliProps.tasksJson)
+}
+
+async function run (cliProps, envProps, configProps = {}) {
+  if (isSilent(cliProps)) stdout.mute()
+
+  const { gulp, tasks } = (
+    await Promise.resolve({ cliProps, envProps, configProps })
+      .then(getImportFromModulePath)
+      .then(getImportFromConfigPath)
+  )
+
+  listenForGulpEvents(gulp)
+  listenForSyncEvents(gulp, cliProps)
+  registerGulpTasks(gulp, tasks)
+
+  stdout.unmute()
+
+  return (
+    runGulpTasks(gulp, cliProps, envProps, configProps)
+  )
+}
+
+export default run

package/lib/log/listen-for-gulp-events.mjs

@@ -0,0 +1,46 @@
+import log from 'gulplog'
+import prettyHrtime from 'pretty-hrtime'
+
+import ansi from '../ansi.mjs'
+import formatError from '../format-error.mjs'
+
+const errors = new Set()
+
+function start (event) {
+  const level = event.branch ? 'debug' : 'info'
+  log[level](`Starting '${ansi.cyan(event.name)}'...`)
+}
+
+function stop (event) {
+  const level = event.branch ? 'debug' : 'info'
+  log[level](`Finished '${ansi.cyan(event.name)}' after ${ansi.magenta(prettyHrtime(event.duration))}`)
+}
+
+function error (event) {
+  const level = event.branch ? 'debug' : 'error'
+  log[level](`'${ansi.cyan(event.name)}' ${ansi.red('errored after')} ${ansi.magenta(prettyHrtime(event.duration))}`)
+
+  // Exit if we have logged this before
+  if (errors.has(event.error)) return
+
+  // If we haven't logged this before, log it and add it to the error list
+  log.error(formatError(event))
+  errors.add(event.error)
+}
+
+function stopListeningForGulpEvents (gulp) {
+  gulp
+    .removeListener('start', start)
+    .removeListener('stop', stop)
+    .removeListener('error', error)
+}
+
+// Wire up logging events
+export default function listenForGulpEvents (gulp) {
+  stopListeningForGulpEvents(gulp)
+
+  gulp
+    .on('start', start)
+    .on('stop', stop)
+    .on('error', error)
+}

package/lib/log/listen-for-level-events.mjs

@@ -0,0 +1,49 @@
+import log from 'gulplog'
+import fancyLog from 'fancy-log'
+
+const noop = () => {}
+
+// The sorting of the levels is
+// significant.
+const levels = [
+  'error', // -L: Logs error events.
+  'warn', // -LL: Logs warn and error events.
+  'info', // -LLL: Logs info, warn and error events.
+  'debug' // -LLLL: Logs all log levels.
+]
+
+function stopListeningForLevelEvents () {
+  levels
+    .forEach((level) => {
+      if (level === 'error') {
+        log.removeListener(level, noop).removeListener(level, fancyLog.error)
+      } else {
+        log.removeListener(level, fancyLog)
+      }
+    })
+}
+
+// Wire up log levels
+export default function listenForLevelEvents (cliProps) {
+  // Remove previous listeners to enable to call this twice.
+  stopListeningForLevelEvents()
+
+  // Silent?
+  if (cliProps.tasksList || cliProps.tasksJson || cliProps.help || cliProps.version || cliProps.silent) {
+    // Keep from crashing process when silent
+    log.on('error', noop)
+  } else {
+    // Default level is 3 (info)
+    const loglevel = cliProps.logLevel || 3
+
+    levels
+      .filter((level, i) => level && i < loglevel)
+      .forEach((level) => {
+        if (level === 'error') {
+          log.on(level, fancyLog.error)
+        } else {
+          log.on(level, fancyLog)
+        }
+      })
+  }
+}

package/lib/log/listen-for-sync-events.mjs

@@ -0,0 +1,58 @@
+import log from 'gulplog'
+import ansi from '../ansi.mjs'
+
+const tasks = new Map()
+
+function warn () {
+  if (tasks.size) {
+    const taskNames = Array.from(tasks.values()).join(', ')
+
+    process.exitCode = 1
+
+    log.warn(
+      ansi.red('The following tasks did not complete:')
+    )
+    log.warn(
+      ansi.cyan(taskNames)
+    )
+    log.warn(
+      ansi.red('Did you forget to signal async completion?')
+    )
+  }
+}
+
+function start ({ uid, name }) {
+  tasks.set(uid, name)
+}
+
+function clear ({ uid }) {
+  tasks.delete(uid)
+}
+
+function clearAll () {
+  tasks.clear()
+}
+
+function stopListeningForSyncEvents (gulp) {
+  // Ensure to detach
+  process
+    .removeListener('exit', warn)
+
+  gulp
+    .removeListener('start', start)
+    .removeListener('stop', clear)
+    .removeListener('error', clear).removeListener('error', clearAll)
+}
+
+export default function listenForSyncEvents (gulp, cliProps) {
+  stopListeningForSyncEvents(gulp)
+
+  process
+    .once('exit', warn)
+
+  // When not running in --continue mode we need to clear everything on error
+  gulp
+    .on('start', start)
+    .on('stop', clear)
+    .on('error', cliProps.continue ? clear : clearAll)
+}

package/lib/log/tasks-json.mjs

@@ -0,0 +1,16 @@
+import {
+  writeFile
+} from 'node:fs/promises'
+
+import getDuplicate from '../get-duplicate.mjs'
+
+export default function logTasksJson (tree, cliProps) {
+  const dupe = getDuplicate(tree, cliProps)
+  const json = JSON.stringify(dupe)
+
+  // Write to a file if not `true`
+  if (cliProps.tasksJson !== true) return writeFile(cliProps.tasksJson, json, 'utf8')
+
+  // Otherwise
+  console.log(json.trim())
+}

package/lib/log/tasks-list.mjs

@@ -0,0 +1,3 @@
+export default function logTasksList ({ nodes = [] }) {
+  console.log(nodes.join('\n').trim())
+}

package/lib/log/tasks.mjs

@@ -0,0 +1,163 @@
+import archy from 'archy'
+import log from 'gulplog'
+
+import sortBy from 'array-sort'
+import isObject from 'isobject'
+
+import ansi from '../ansi.mjs'
+import getDuplicate from '../get-duplicate.mjs'
+
+function getLineInfoCollector (lineInfo) {
+  return {
+    topTask (node) {
+      lineInfo.push({
+        name: node.label,
+        desc: node.desc,
+        type: 'top'
+      })
+    },
+    option (opt) {
+      lineInfo.push({
+        name: opt.label,
+        desc: opt.desc,
+        type: 'option'
+      })
+    },
+    childTask (node) {
+      lineInfo.push({
+        name: node.label,
+        type: 'child'
+      })
+    }
+  }
+}
+
+function getNodeFactory (getTask, entryObserver) {
+  return {
+    topNode (node) {
+      return {
+        label: node.label
+      }
+    },
+
+    taskNode (node) {
+      const task = getTask(node.label) || {}
+
+      const newNode = {
+        label: node.label,
+        desc: typeof task.description === 'string' ? task.description : '',
+        cliProps: []
+      }
+      entryObserver.topTask(newNode)
+
+      if (isObject(task.flags)) {
+        Object.keys(task.flags)
+          .sort()
+          .filter(Boolean)
+          .forEach((flag) => {
+            const opt = {
+              label: flag,
+              desc: typeof task.flags[flag] === 'string' ? task.flags[flag] : ''
+            }
+            entryObserver.option(opt)
+            newNode.cliProps.push(opt)
+            newNode.label += '\n' + opt.label // The way of archy for options.
+          })
+      }
+
+      return newNode
+    },
+
+    childNode (node) {
+      const newChild = {
+        label: node.label
+      }
+      entryObserver.childTask(newChild)
+      newChild.label = '' // Because don't use child tasks to calc indents.
+
+      return newChild
+    }
+  }
+}
+
+function getSpacerForLineIndents (tree, lineInfo) {
+  let maxSize = 0
+  const sizes = []
+
+  archy(tree)
+    .split('\n')
+    .slice(1, -1)
+    .forEach((line, index) => {
+      const info = lineInfo[index]
+      if (info.type === 'top' || info.type === 'option') {
+        maxSize = Math.max(maxSize, line.length)
+        sizes.push(line.length)
+      } else {
+        sizes.push(0)
+      }
+    })
+
+  maxSize += 3
+
+  return function getSpacerFor (index) {
+    return Array(maxSize - sizes[index]).join(' ')
+  }
+}
+
+function getLinesContainingOnlyBranches (tree) {
+  tree.nodes
+    .forEach((node) => {
+      node.label = ''
+      node.cliProps
+        .forEach(() => {
+          node.label += '\n'
+        })
+    })
+
+  return archy(tree)
+    .split('\n')
+    .slice(1, -1)
+}
+
+function logLines (lines, spacer, lineInfo) {
+  lines
+    .forEach((branch, index) => {
+      const info = lineInfo[index]
+
+      let line = ansi.white(branch)
+
+      if (info.type === 'top') {
+        line += ansi.cyan(info.name)
+        if (info.desc.length > 0) {
+          line += spacer(index) + ansi.white(info.desc)
+        }
+      } else if (info.type === 'option') {
+        line += ansi.magenta(info.name)
+        if (info.desc.length > 0) {
+          line += spacer(index) + ansi.white('…' + info.desc)
+        }
+      } else { // If (info.type === 'child') {
+        line += ansi.white(info.name)
+      }
+
+      log.info(line)
+    })
+}
+
+// Wire up log tasks
+export default function logTasks (tree, cliProps, getTask) {
+  if (cliProps.sortTasks) {
+    tree.nodes = sortBy(tree.nodes, 'label')
+  }
+
+  const lineInfo = []
+  const entryObserver = getLineInfoCollector(lineInfo)
+  const nodeFactory = getNodeFactory(getTask, entryObserver)
+
+  const dupe = getDuplicate(tree, cliProps, nodeFactory)
+  const spacer = getSpacerForLineIndents(dupe, lineInfo)
+  const lines = getLinesContainingOnlyBranches(dupe)
+
+  log.info(dupe.label)
+  logLines(lines, spacer, lineInfo)
+}

package/lib/register-gulp-tasks.mjs

@@ -0,0 +1,7 @@
+export default function registerGulpTasks (gulp, tasks) {
+  Object.entries(tasks)
+    .filter(([taskName, task]) => (taskName || task.displayName) && task instanceof Function)
+    .forEach(([taskName, task]) => {
+      gulp.task(task.displayName || taskName, task)
+    })
+}

package/lib/run-gulp-tasks-json-tree.mjs

@@ -0,0 +1,14 @@
+import tildify from './tildify.mjs'
+
+import logTasksJson from './log/tasks-json.mjs'
+
+export default function runGulpTasksJsonTree (gulp, cliProps, envProps, configProps) {
+  const tree = gulp.tree({ deep: true })
+  if (configProps.description && typeof configProps.description === 'string') {
+    tree.label = configProps.description
+  } else {
+    tree.label = `Tasks for ${tildify(envProps.configPath)}`
+  }
+
+  return logTasksJson(tree, cliProps)
+}

package/lib/run-gulp-tasks-list-tree.mjs

@@ -0,0 +1,7 @@
+import logTasksList from './log/tasks-list.mjs'
+
+export default function runGulpTasksListTree (gulp) {
+  const tree = gulp.tree()
+
+  return logTasksList(tree)
+}