watchful-cli 1.7.57 → 1.7.59

package/lib/utilities/transpile.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createTranspileFileFunction", {
+    enumerable: true,
+    get: function() {
+        return createTranspileFileFunction;
+    }
+});
+var _path = /*#__PURE__*/ _interop_require_default(require("path"));
+var _necessary = require("necessary");
+var _paths = require("../paths");
+var _fileSystem = require("../utilities/fileSystem");
+var _constants = require("../constants");
+var _messages = require("../messages");
+var _path1 = require("../utilities/path");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var BASE64_ENCODING = _necessary.encodings.BASE64_ENCODING;
+function createTranspileFileFunction(context) {
+    var debug = context.debug, transpiler = context.transpiler, transpileFileFunction = transpiler === _constants.BABEL ? createBabelTranspileFileFunction(debug) : createSWCTranspileFileFunction(debug);
+    return transpileFileFunction;
+}
+function createBabelTranspileFileFunction(debug) {
+    var babelTranspileFileFunction = null;
+    try {
+        var babelCorePath = _path.default.resolve(_paths.BABEL_CORE_PATH), babel = require(babelCorePath), transpiler = babel; ///
+        babelTranspileFileFunction = function(filePath, sourceDirectoryPath, targetDirectoryPath, callback) {
+            var options;
+            var sourceFilePath = (0, _path1.sourceFilePathFromFilePathAndSourceDirectoryPath)(filePath, sourceDirectoryPath), targetFilePath = (0, _path1.targetFilePathFromFilePathAndTargetDirectoryPath)(filePath, targetDirectoryPath);
+            if (debug) {
+                var sourceMaps = _constants.INLINE, sourceFileName = (0, _path1.sourceFileNameFromSourceFilePathAndTargetFilePath)(sourceFilePath, targetFilePath);
+                options = {
+                    sourceMaps: sourceMaps,
+                    sourceFileName: sourceFileName
+                };
+            } else {
+                options = {};
+            }
+            transpiler.transformFile(sourceFilePath, options, function(error, result) {
+                if (error) {
+                    var success = false, message = error.message;
+                    error = message; ///
+                    console.log("".concat(_messages.BABEL_FAILED_MESSAGE, "\n").concat(error));
+                    callback(success);
+                    return;
+                }
+                var code = result.code, success1 = true, targetFileContent = code; ///
+                (0, _fileSystem.createParentDirectory)(targetFilePath);
+                (0, _fileSystem.writeFile)(targetFilePath, targetFileContent);
+                callback(success1);
+            });
+        };
+    } catch (error) {
+        console.log(_messages.BABEL_NOT_INSTALLED_MESSAGE);
+    }
+    return babelTranspileFileFunction;
+}
+function createSWCTranspileFileFunction(debug) {
+    var swcTranspileFileFunction = null;
+    try {
+        var swcCorePath = _path.default.resolve(_paths.SWC_CORE_PATH), swc = require(swcCorePath), transpiler = swc; ///
+        swcTranspileFileFunction = function(filePath, sourceDirectoryPath, targetDirectoryPath, callback) {
+            var sourceFilePath = (0, _path1.sourceFilePathFromFilePathAndSourceDirectoryPath)(filePath, sourceDirectoryPath), targetFilePath = (0, _path1.targetFilePathFromFilePathAndTargetDirectoryPath)(filePath, targetDirectoryPath), filename = targetFilePath, sourceMaps = debug, sourceFileContent = (0, _fileSystem.readFile)(sourceFilePath), options = {
+                filename: filename,
+                sourceMaps: sourceMaps
+            };
+            transpiler.transform(sourceFileContent, options).then(function(output) {
+                var success = true;
+                var targetFileContent;
+                if (debug) {
+                    var code = output.code, map = output.map, mapJSON = JSON.parse(map);
+                    var sources = mapJSON.sources;
+                    sources = (0, _path1.sourcesFromSourcesSourceDirectoryPathAndTargetDirectoryPath)(sources, sourceDirectoryPath, targetDirectoryPath);
+                    Object.assign(mapJSON, {
+                        sources: sources
+                    });
+                    var mapJSONString = JSON.stringify(mapJSON), base64EncodedMapJSONString = Buffer.from(mapJSONString).toString(BASE64_ENCODING);
+                    targetFileContent = "".concat(code, "\n").concat(_constants.SOURCE_MAP_PREAMBLE).concat(base64EncodedMapJSONString); ///
+                } else {
+                    var code1 = output.code;
+                    targetFileContent = code1; ///
+                }
+                (0, _fileSystem.createParentDirectory)(targetFilePath);
+                (0, _fileSystem.writeFile)(targetFilePath, targetFileContent);
+                callback(success);
+            }).catch(function(error) {
+                var success = false;
+                console.log("".concat(_messages.SWC_FAILED_MESSAGE, "\n").concat(error));
+                callback(success);
+            });
+        };
+    } catch (error) {
+        console.log(_messages.SWC_NOT_INSTALLED_MESSAGE);
+    }
+    return swcTranspileFileFunction;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/transpile.js"],"sourcesContent":["\"use strict\";\n\nimport path from \"path\";\n\nimport { encodings } from \"necessary\";\n\nimport { SWC_CORE_PATH, BABEL_CORE_PATH } from \"../paths\";\nimport { readFile, writeFile, createParentDirectory } from \"../utilities/fileSystem\";\nimport { BABEL, INLINE, SOURCE_MAP_PREAMBLE } from \"../constants\";\nimport { SWC_FAILED_MESSAGE, BABEL_FAILED_MESSAGE, SWC_NOT_INSTALLED_MESSAGE, BABEL_NOT_INSTALLED_MESSAGE } from \"../messages\";\nimport { sourceFilePathFromFilePathAndSourceDirectoryPath,\n         targetFilePathFromFilePathAndTargetDirectoryPath,\n         sourceFileNameFromSourceFilePathAndTargetFilePath,\n         sourcesFromSourcesSourceDirectoryPathAndTargetDirectoryPath } from \"../utilities/path\";\n\nconst { BASE64_ENCODING } = encodings;\n\nexport function createTranspileFileFunction(context) {\n  const { debug, transpiler } = context,\n        transpileFileFunction = (transpiler === BABEL) ?\n                                  createBabelTranspileFileFunction(debug) :\n                                    createSWCTranspileFileFunction(debug);\n\n  return transpileFileFunction;\n}\n\nfunction createBabelTranspileFileFunction(debug) {\n  let babelTranspileFileFunction = null;\n\n  try {\n    const babelCorePath = path.resolve(BABEL_CORE_PATH),\n          babel = require(babelCorePath),\n          transpiler = babel; ///\n\n    babelTranspileFileFunction = (filePath, sourceDirectoryPath, targetDirectoryPath, callback) => {\n      let options;\n\n      const sourceFilePath = sourceFilePathFromFilePathAndSourceDirectoryPath(filePath, sourceDirectoryPath),\n            targetFilePath = targetFilePathFromFilePathAndTargetDirectoryPath(filePath, targetDirectoryPath);\n\n      if (debug) {\n        const sourceMaps = INLINE,  ///\n              sourceFileName = sourceFileNameFromSourceFilePathAndTargetFilePath(sourceFilePath, targetFilePath);\n\n        options = {\n          sourceMaps,\n          sourceFileName\n        };\n      } else {\n        options = {};\n      }\n\n      transpiler.transformFile(sourceFilePath, options, (error, result) => {\n        if (error) {\n          const success = false,\n                { message } = error;\n\n          error = message;  ///\n\n          console.log(`${BABEL_FAILED_MESSAGE}\n${error}`);\n\n          callback(success);\n\n          return;\n        }\n\n        const { code } = result,\n              success = true,\n              targetFileContent = code; ///\n\n        createParentDirectory(targetFilePath);\n\n        writeFile(targetFilePath, targetFileContent);\n\n        callback(success);\n      });\n    };\n  } catch (error) {\n    console.log(BABEL_NOT_INSTALLED_MESSAGE);\n  }\n\n  return babelTranspileFileFunction;\n}\n\nfunction createSWCTranspileFileFunction(debug) {\n  let swcTranspileFileFunction = null;\n\n  try {\n    const swcCorePath = path.resolve(SWC_CORE_PATH),\n          swc = require(swcCorePath),\n          transpiler = swc; ///\n\n    swcTranspileFileFunction = (filePath, sourceDirectoryPath, targetDirectoryPath, callback) => {\n      const sourceFilePath = sourceFilePathFromFilePathAndSourceDirectoryPath(filePath, sourceDirectoryPath),\n            targetFilePath = targetFilePathFromFilePathAndTargetDirectoryPath(filePath, targetDirectoryPath),\n            filename = targetFilePath,  ///\n            sourceMaps = debug, ///\n            sourceFileContent = readFile(sourceFilePath),\n            options = {\n              filename,\n              sourceMaps\n            };\n\n      transpiler.transform(sourceFileContent, options)\n        .then((output) => {\n          const success = true;\n\n          let targetFileContent;\n\n          if (debug) {\n            const { code, map } = output,\n                  mapJSON = JSON.parse(map);\n\n            let { sources } = mapJSON;\n\n            sources = sourcesFromSourcesSourceDirectoryPathAndTargetDirectoryPath(sources, sourceDirectoryPath, targetDirectoryPath);\n\n            Object.assign(mapJSON, {\n              sources\n            });\n\n            const mapJSONString = JSON.stringify(mapJSON),\n                  base64EncodedMapJSONString = Buffer.from(mapJSONString).toString(BASE64_ENCODING);\n\n            targetFileContent = `${code}\n${SOURCE_MAP_PREAMBLE}${base64EncodedMapJSONString}`; ///\n          } else {\n            const { code } = output;\n\n            targetFileContent = code; ///\n          }\n\n          createParentDirectory(targetFilePath);\n\n          writeFile(targetFilePath, targetFileContent);\n\n          callback(success);\n        })\n        .catch((error) => {\n          const success = false;\n\n          console.log(`${SWC_FAILED_MESSAGE}\n${error}`);\n\n          callback(success);\n        });\n    };\n  } catch (error) {\n    console.log(SWC_NOT_INSTALLED_MESSAGE);\n  }\n\n  return swcTranspileFileFunction;\n}\n\n"],"names":["createTranspileFileFunction","BASE64_ENCODING","encodings","context","debug","transpiler","transpileFileFunction","BABEL","createBabelTranspileFileFunction","createSWCTranspileFileFunction","babelTranspileFileFunction","babelCorePath","path","resolve","BABEL_CORE_PATH","babel","require","filePath","sourceDirectoryPath","targetDirectoryPath","callback","options","sourceFilePath","sourceFilePathFromFilePathAndSourceDirectoryPath","targetFilePath","targetFilePathFromFilePathAndTargetDirectoryPath","sourceMaps","INLINE","sourceFileName","sourceFileNameFromSourceFilePathAndTargetFilePath","transformFile","error","result","success","message","console","log","BABEL_FAILED_MESSAGE","code","targetFileContent","createParentDirectory","writeFile","BABEL_NOT_INSTALLED_MESSAGE","swcTranspileFileFunction","swcCorePath","SWC_CORE_PATH","swc","filename","sourceFileContent","readFile","transform","then","output","map","mapJSON","JSON","parse","sources","sourcesFromSourcesSourceDirectoryPathAndTargetDirectoryPath","Object","assign","mapJSONString","stringify","base64EncodedMapJSONString","Buffer","from","toString","SOURCE_MAP_PREAMBLE","catch","SWC_FAILED_MESSAGE","SWC_NOT_INSTALLED_MESSAGE"],"mappings":"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"}

package/lib/utilities/watch.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get eventHandler () {
+        return eventHandler;
+    },
+    get queueEmptyHandler () {
+        return queueEmptyHandler;
+    }
+});
+var _deleteFile = /*#__PURE__*/ _interop_require_default(require("../task/deleteFile"));
+var _bundleFiles = /*#__PURE__*/ _interop_require_default(require("../task/bundleFiles"));
+var _transpileFile = /*#__PURE__*/ _interop_require_default(require("../task/transpileFile"));
+var _deleteDirectory = /*#__PURE__*/ _interop_require_default(require("../task/deleteDirectory"));
+var _path = require("../utilities/path");
+var _events = require("../events");
+var _metrics = require("../utilities/metrics");
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function eventHandler(queue, event, path, context) {
+    var metrics = context.metrics, pathFullyQualifiedPath = (0, _path.isPathFullQualifiedPath)(path);
+    if (pathFullyQualifiedPath) {
+        var fullyQualifiedPath = path; ///
+        path = (0, _path.pathFromFullyQualifiedPath)(fullyQualifiedPath);
+    }
+    if (metrics) {
+        var empty = queue.isEmpty();
+        if (empty) {
+            (0, _metrics.startCountMetric)(context);
+            (0, _metrics.startSecondsMetric)(context);
+        }
+    }
+    switch(event){
+        case _events.ADD_EVENT:
+        case _events.CHANGE_EVENT:
+            addOrChangeEventHandler(queue, path, context);
+            break;
+        case _events.UNLINK_DIR_EVENT:
+            unlinkDirEventHandler(queue, context);
+            break;
+        case _events.UNLINK_EVENT:
+            unlinkEventHandler(queue, path, context);
+            break;
+    }
+}
+function queueEmptyHandler(queue, previousTask, context) {
+    if (_instanceof(previousTask, _bundleFiles.default)) {
+        return;
+    }
+    var wait = context.wait, metrics = context.metrics;
+    if (metrics) {
+        var count = (0, _metrics.endCountMetric)(context), seconds = (0, _metrics.endSecondsMetric)(context), sOrEmpty = count === 1 ? "" : "s";
+        console.log("Transpiled ".concat(count, " file").concat(sOrEmpty, " in ").concat(seconds, " seconds."));
+    }
+    setTimeout(function() {
+        var empty = queue.isEmpty();
+        if (empty) {
+            var bundleFilesTask = _bundleFiles.default.fromContext(context);
+            if (bundleFilesTask !== null) {
+                queue.addTask(bundleFilesTask);
+            }
+        }
+    }, wait);
+}
+function addOrChangeEventHandler(queue, path, context) {
+    var transpileFileTask = _transpileFile.default.fromPath(path, context);
+    if (transpileFileTask !== null) {
+        queue.addTask(transpileFileTask);
+    }
+}
+function unlinkDirEventHandler(queue, path, context) {
+    var deleteDirectoryTask = _deleteDirectory.default.fromPath(path, context);
+    if (deleteDirectoryTask !== null) {
+        queue.addTask(deleteDirectoryTask);
+    }
+}
+function unlinkEventHandler(queue, path, context) {
+    var deleteFileTask = _deleteFile.default.fromPath(path, context);
+    if (deleteFileTask !== null) {
+        queue.addTask(deleteFileTask);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/watch.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return watch;
+    }
+});
+var _chokidar = /*#__PURE__*/ _interop_require_default(require("chokidar"));
+var _queue = /*#__PURE__*/ _interop_require_default(require("./queue"));
+var _events = require("./events");
+var _constants = require("./constants");
+var _watch = require("./utilities/watch");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function watch(context) {
+    var quietly = context.quietly, sourceDirectoryPath = context.sourceDirectoryPath, watchPattern = "".concat(sourceDirectoryPath).concat(_constants.SOURCE_DIRECTORY_WATCH_PATTERN), watcher = _chokidar.default.watch(watchPattern), queue = _queue.default.fromEmptyHandler(function(previousTask) {
+        return (0, _watch.queueEmptyHandler)(queue, previousTask, context);
+    });
+    watcher.on(_events.READY_EVENT, function() {
+        if (!quietly) {
+            console.log("Watching '".concat(watchPattern, "'."));
+        }
+        watcher.on(_events.ALL_EVENT, function(event, path) {
+            return (0, _watch.eventHandler)(queue, event, path, context);
+        });
+    });
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/wrapper/transpileFile.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return TranspileFileWrapper;
+    }
+});
+var _child_process = /*#__PURE__*/ _interop_require_default(require("child_process"));
+var _constants = require("../constants");
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var TranspileFileWrapper = /*#__PURE__*/ function() {
+    function TranspileFileWrapper(process, callback, parameters) {
+        _class_call_check(this, TranspileFileWrapper);
+        this.process = process;
+        this.callback = callback;
+        this.parameters = parameters;
+    }
+    _create_class(TranspileFileWrapper, [
+        {
+            key: "getProcess",
+            value: function getProcess() {
+                return this.process;
+            }
+        },
+        {
+            key: "getCallback",
+            value: function getCallback() {
+                return this.callback;
+            }
+        },
+        {
+            key: "setParameters",
+            value: function setParameters(parameters) {
+                this.parameters = parameters;
+            }
+        },
+        {
+            key: "getParameters",
+            value: function getParameters() {
+                return this.parameters;
+            }
+        },
+        {
+            key: "send",
+            value: function send(filePath) {
+                this.process.send(filePath);
+            }
+        },
+        {
+            key: "messageHandler",
+            value: function messageHandler(success) {
+                var transpileFileWrapper = this; ///
+                this.callback(transpileFileWrapper, success);
+            }
+        }
+    ], [
+        {
+            key: "fromCallback",
+            value: function fromCallback(callback, context) {
+                var debug = context.debug, quietly = context.quietly, transpiler = context.transpiler, sourceDirectoryPath = context.sourceDirectoryPath, targetDirectoryPath = context.targetDirectoryPath;
+                context = {
+                    debug: debug,
+                    quietly: quietly,
+                    transpiler: transpiler,
+                    sourceDirectoryPath: sourceDirectoryPath,
+                    targetDirectoryPath: targetDirectoryPath
+                };
+                var contextString = JSON.stringify(context), args = [
+                    contextString
+                ], process = _child_process.default.fork(require.resolve(_constants.PROCESS_TRANSPILE_FILE), args), parameters = null, transpileFileWrapper = new TranspileFileWrapper(process, callback, parameters);
+                process.on(_constants.MESSAGE, function(message) {
+                    return transpileFileWrapper.messageHandler(message);
+                });
+                return transpileFileWrapper;
+            }
+        }
+    ]);
+    return TranspileFileWrapper;
+}();
+
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "watchful-cli",
   "author": "James Smith",
-  "version": "1.7.57",
+  "version": "1.7.59",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/watchful-cli",
   "description": "Incremental transpilation with bundling.",
@@ -9,13 +9,28 @@
     "type": "git",
     "url": "https://github.com/djalbat/watchful-cli"
   },
-  "bin": {
-    "watchful": "./watchful.js"
-  },
   "dependencies": {
     "argumentative": "^2.0.32",
     "chokidar": "^3.3.1",
-    "necessary": "^14.0.1"
+    "necessary": "^15.0.2"
+  },
+  "devDependencies": {
+    "@swc/core": "1.13.20",
+    "watchful-cli": "^1.7.56"
   },
-  "scripts": {}
+  "scripts": {
+    "clean": "rm -rf ./lib",
+    "watchful": "watchful -m --transpiler=swc --source-directory=./src --lib-directory=./lib --pause=100",
+    "batch": "npm run watchful batch --",
+    "batch-debug": "npm run watchful batch -- --debug",
+    "incremental": "npm run watchful incremental --",
+    "incremental-debug": "npm run watchful incremental -- --debug",
+    "build": "npm run clean && npm run batch",
+    "build-debug": "npm run clean && npm run batch-debug",
+    "watch": "npm run clean && npm run batch && npm run incremental",
+    "watch-debug": "npm run clean && npm run batch-debug && npm run incremental-debug"
+  },
+  "bin": {
+    "watchful": "./watchful.js"
+  }
 }

package/{bin → src}/abbreviations.js

@@ -1,27 +1,25 @@
 "use strict";
 
-const { HELP_OPTION,
-        NODE_OPTION,
-        WAIT_OPTION,
-        DEBUG_OPTION,
-        RELEASE_OPTION,
-        BUNDLER_OPTION,
-        QUIETLY_OPTION,
-        VERSION_OPTION,
-        METRICS_OPTION,
-        PROCESSES_OPTION,
-        TRANSPILER_OPTION,
-        ENTRY_FILE_OPTION,
-        BUNDLE_FILE_OPTION,
-        LIB_DIRECTORY_OPTION,
-        TEMP_DIRECTORY_OPTION,
-        SOURCE_DIRECTORY_OPTION } = require("./options");
+import { HELP_OPTION,
+         NODE_OPTION,
+         WAIT_OPTION,
+         DEBUG_OPTION,
+         BUNDLER_OPTION,
+         QUIETLY_OPTION,
+         VERSION_OPTION,
+         METRICS_OPTION,
+         PROCESSES_OPTION,
+         TRANSPILER_OPTION,
+         ENTRY_FILE_OPTION,
+         BUNDLE_FILE_OPTION,
+         LIB_DIRECTORY_OPTION,
+         TEMP_DIRECTORY_OPTION,
+         SOURCE_DIRECTORY_OPTION } from "./options";
 
 const h = HELP_OPTION,
       n = NODE_OPTION,
       w = WAIT_OPTION,
       d = DEBUG_OPTION,
-      r = RELEASE_OPTION,
       u = BUNDLER_OPTION,
       q = QUIETLY_OPTION,
       v = VERSION_OPTION,
@@ -34,12 +32,11 @@ const h = HELP_OPTION,
       x = TEMP_DIRECTORY_OPTION,
       s = SOURCE_DIRECTORY_OPTION;
 
-module.exports = {
+const abbreviations = {
   h,
   n,
   w,
   d,
-  r,
   u,
   q,
   v,
@@ -52,3 +49,5 @@ module.exports = {
   x,
   s
 };
+
+export default abbreviations;

package/src/action/batch.js

@@ -0,0 +1,46 @@
+"use strict";
+
+import action from "../action";
+import initialiseOperation from "../operation/initialise";
+import bundleFilesOperation from "../operation/bundleFiles";
+import transpileFilesOperation from "../operation/transpileFiles";
+import retrieveFilePathsOperation from "../operation/retrieveFilePaths";
+import createBundleFilesFunctionOperation from "../operation/createBundleFilesFunction";
+import createTranspileFileFunctionOperation from "../operation/createTranspileFileFunction";
+
+import { BATCH_BUILD_FAILED_MESSAGE } from "../messages";
+
+export default function batchAction(wait, node, debug, release, bundler, quietly, metrics, processes, entryFile, transpiler, bundleFile, libDirectory, tempDirectory, sourceDirectory) {
+  const operations = [
+          initialiseOperation,
+          createTranspileFileFunctionOperation,
+          createBundleFilesFunctionOperation,
+          retrieveFilePathsOperation,
+          transpileFilesOperation,
+          bundleFilesOperation
+        ],
+        context = {
+          wait,
+          node,
+          debug,
+          release,
+          bundler,
+          quietly,
+          metrics,
+          processes,
+          entryFile,
+          transpiler,
+          bundleFile,
+          libDirectory,
+          tempDirectory,
+          sourceDirectory
+        };
+
+  action(operations, (success) => {
+    if (!success) {
+      console.log(BATCH_BUILD_FAILED_MESSAGE);
+    }
+
+    process.exit(); ///
+  }, context);
+}

package/{bin → src}/action/help.js

@@ -1,6 +1,6 @@
 "use strict";
 
-function helpAction() {
+export default function helpAction() {
   console.log(`Usage: 
   
   watchful [<options>] [<command>] [<argument>] 
@@ -56,5 +56,3 @@ Please see the readme file on GitHub:
   https://github.com/djalbat/watchful-cli
 `);
 }
-
-module.exports = helpAction;

package/{bin → src}/action/incremental.js

@@ -1,15 +1,15 @@
 "use strict";
 
-const watch = require("../watch"),
-      action = require("../action"),
-      initialiseOperation = require("../operation/initialise"),
-      retrieveFilePathsOperation = require("../operation/retrieveFilePaths"),
-      createBundleFilesFunctionOperation = require("../operation/createBundleFilesFunction"),
-      createTranspileFileFunctionOperation = require("../operation/createTranspileFileFunction");
+import watch from "../watch";
+import action from "../action";
+import initialiseOperation from "../operation/initialise";
+import retrieveFilePathsOperation from "../operation/retrieveFilePaths";
+import createBundleFilesFunctionOperation from "../operation/createBundleFilesFunction";
+import createTranspileFileFunctionOperation from "../operation/createTranspileFileFunction";
 
-const { INCREMENTAL_BUILD_FAILED_MESSAGE } = require("../messages");
+import { INCREMENTAL_BUILD_FAILED_MESSAGE } from "../messages";
 
-function incrementalAction(wait, node, debug, release, bundler, quietly, metrics, processes, entryFile, transpiler, bundleFile, libDirectory, tempDirectory, sourceDirectory) {
+export default function incrementalAction(wait, node, debug, release, bundler, quietly, metrics, processes, entryFile, transpiler, bundleFile, libDirectory, tempDirectory, sourceDirectory) {
   const operations = [
           initialiseOperation,
           createTranspileFileFunctionOperation,
@@ -43,5 +43,3 @@ function incrementalAction(wait, node, debug, release, bundler, quietly, metrics
     watch(context);
   }, context);
 }
-
-module.exports = incrementalAction;

package/src/action/version.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import { packageUtilities } from "necessary";
+
+import { WATCHFUL_CLI } from "../constants";
+
+const { getVersion } = packageUtilities;
+
+export default function versionAction() {
+  const version = getVersion(); ///
+
+  console.log(`${WATCHFUL_CLI} version ${version}`);
+}

package/{bin → src}/action.js

@@ -1,13 +1,11 @@
 "use strict";
 
-const { executeOperations } = require("./utilities/callback");
+import { executeOperations } from "./utilities/callback";
 
-function action(operations, callback, context) {
+export default function action(operations, callback, context) {
   executeOperations(operations, (completed) => {
     const success = completed;  ///
 
     callback(success);
   }, context);
 }
-
-module.exports = action;

package/{bin → src}/bundleFiles.js

@@ -1,8 +1,8 @@
 "use strict";
 
-const { startSecondsMetric, endSecondsMetric } = require("./utilities/metrics");
+import { startSecondsMetric, endSecondsMetric } from "./utilities/metrics";
 
-function bundleFiles(context, done) {
+export default function bundleFiles(context, done) {
   const { metrics, entryFilePath, bundleFilePath, targetDirectoryPath, bundleFilesFunction } = context;
 
   if (metrics) {
@@ -31,5 +31,3 @@ function bundleFiles(context, done) {
     done();
   });
 }
-
-module.exports = bundleFiles;

package/src/commands.js

@@ -0,0 +1,6 @@
+"use strict";
+
+export const HELP_COMMAND = "help";
+export const BATCH_COMMAND = "batch";
+export const VERSION_COMMAND = "version";
+export const INCREMENTAL_COMMAND = "incremental";