@leverege/build-tools 1.8.4

package/lib/web/packleate/Packleator.js

@@ -0,0 +1,645 @@
+"use strict";
+
+require("core-js/modules/es6.symbol");
+
+require("core-js/modules/es6.regexp.split");
+
+require("core-js/modules/es6.regexp.to-string");
+
+require("core-js/modules/es6.promise");
+
+require("core-js/modules/es6.string.starts-with");
+
+require("core-js/modules/es6.regexp.constructor");
+
+require("core-js/modules/es6.object.keys");
+
+require("core-js/modules/es6.regexp.replace");
+
+require("regenerator-runtime/runtime");
+
+require("core-js/modules/web.dom.iterable");
+
+require("core-js/modules/es6.array.iterator");
+
+require("core-js/modules/es6.object.to-string");
+
+require("core-js/modules/es6.string.iterator");
+
+require("core-js/modules/es6.set");
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+
+function _classCallCheck(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 _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var exec = require('child_process').exec;
+
+var fs = require('fs-extra');
+
+var path = require('path');
+
+var async = require('async');
+
+var copy = require('recursive-copy');
+
+var ora = require('ora');
+
+var tar = require('tar');
+
+var semver = require('semver');
+
+var Packleator =
+/*#__PURE__*/
+function () {
+  function Packleator(options) {
+    _classCallCheck(this, Packleator);
+
+    var args = options.args;
+    this.privatePackages = new Set();
+    this.args = args ? _objectSpread({}, args, {
+      output: args.output.substr(-1) === '/' ? args.output.substr(0, args.output.length) : args.output
+    }) : {}; // args || {}
+
+    this.spinner = ora({
+      text: 'Installing NPM dependencies...',
+      spinner: 'monkey'
+    });
+    this.stderr = '';
+    this.tarredVersions = {};
+    this.outputPackageJson = {};
+    this.outputPackageLockJson = {};
+  }
+
+  _createClass(Packleator, [{
+    key: "run",
+    value: function () {
+      var _run = _asyncToGenerator(
+      /*#__PURE__*/
+      regeneratorRuntime.mark(function _callee3() {
+        var _this = this;
+
+        var deps;
+        return regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.prev = 0;
+                this.spinner.start();
+                _context3.next = 4;
+                return this.npmInstall();
+
+              case 4:
+                this.spinner.text = 'Copying files...';
+                _context3.next = 7;
+                return this.copyFiles();
+
+              case 7:
+                process.chdir(this.args.output);
+                _context3.next = 10;
+                return this.getPackageJson();
+
+              case 10:
+                this.outputPackageJson = _context3.sent;
+                _context3.next = 13;
+                return this.getPackageJson(undefined, true);
+
+              case 13:
+                this.outputPackageLockJson = _context3.sent;
+                this.spinner.text = 'Parsing private dependencies...';
+                _context3.next = 17;
+                return this.getPrivateDeps();
+
+              case 17:
+                deps = _context3.sent;
+                this.spinner.text = 'Packaging modules...';
+                async.eachOfSeries(deps,
+                /*#__PURE__*/
+                function () {
+                  var _ref = _asyncToGenerator(
+                  /*#__PURE__*/
+                  regeneratorRuntime.mark(function _callee(item, key) {
+                    var packageJson, name, version;
+                    return regeneratorRuntime.wrap(function _callee$(_context) {
+                      while (1) {
+                        switch (_context.prev = _context.next) {
+                          case 0:
+                            _context.next = 2;
+                            return _this.getPackageJson(item);
+
+                          case 2:
+                            packageJson = _context.sent;
+                            name = packageJson.name, version = packageJson.version;
+                            _context.next = 6;
+                            return _this.pack(name, version, item);
+
+                          case 6:
+                          case "end":
+                            return _context.stop();
+                        }
+                      }
+                    }, _callee);
+                  }));
+
+                  return function (_x, _x2) {
+                    return _ref.apply(this, arguments);
+                  };
+                }(),
+                /*#__PURE__*/
+                function () {
+                  var _ref2 = _asyncToGenerator(
+                  /*#__PURE__*/
+                  regeneratorRuntime.mark(function _callee2(err) {
+                    var _this$outputPackageJs, name, version, fileName;
+
+                    return regeneratorRuntime.wrap(function _callee2$(_context2) {
+                      while (1) {
+                        switch (_context2.prev = _context2.next) {
+                          case 0:
+                            _context2.next = 2;
+                            return _this.rebuildPackageJson();
+
+                          case 2:
+                            _context2.next = 4;
+                            return _this.rebuildPackageLockJson();
+
+                          case 4:
+                            _context2.next = 6;
+                            return fs.writeFile('package.json', JSON.stringify(_this.outputPackageJson, null, 2));
+
+                          case 6:
+                            _context2.next = 8;
+                            return fs.writeFile('package-lock.json', JSON.stringify(_this.outputPackageLockJson, null, 2));
+
+                          case 8:
+                            _context2.next = 10;
+                            return fs.remove('node_modules');
+
+                          case 10:
+                            _this$outputPackageJs = _this.outputPackageJson, name = _this$outputPackageJs.name, version = _this$outputPackageJs.version;
+                            fileName = "".concat(name.replace('@', '').replace('/', '-'), "-").concat(version, ".tgz");
+                            process.chdir('..');
+                            _this.spinner.text = 'Packaging results...';
+                            _context2.next = 16;
+                            return tar.c({
+                              file: fileName,
+                              strict: true,
+                              prefix: 'package/',
+                              C: _this.args.output
+                            }, ['.']);
+
+                          case 16:
+                            _this.spinner.text = 'Cleaning up...';
+                            _context2.next = 19;
+                            return _this.cleanup();
+
+                          case 19:
+                            _this.spinner.stop();
+
+                          case 20:
+                          case "end":
+                            return _context2.stop();
+                        }
+                      }
+                    }, _callee2);
+                  }));
+
+                  return function (_x3) {
+                    return _ref2.apply(this, arguments);
+                  };
+                }());
+                _context3.next = 26;
+                break;
+
+              case 22:
+                _context3.prev = 22;
+                _context3.t0 = _context3["catch"](0);
+                this.spinner.stop();
+                throw _context3.t0;
+
+              case 26:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this, [[0, 22]]);
+      }));
+
+      function run() {
+        return _run.apply(this, arguments);
+      }
+
+      return run;
+    }()
+  }, {
+    key: "rebuildPackageJson",
+    value: function () {
+      var _rebuildPackageJson = _asyncToGenerator(
+      /*#__PURE__*/
+      regeneratorRuntime.mark(function _callee4() {
+        var _this2 = this;
+
+        var packageJson, tarredPackages, _packageJson$dependen, dependencies, _packageJson$devDepen, devDependencies;
+
+        return regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                packageJson = this.outputPackageJson;
+                tarredPackages = Object.keys(this.tarredVersions);
+                _packageJson$dependen = packageJson.dependencies, dependencies = _packageJson$dependen === void 0 ? {} : _packageJson$dependen, _packageJson$devDepen = packageJson.devDependencies, devDependencies = _packageJson$devDepen === void 0 ? {} : _packageJson$devDepen;
+                tarredPackages.forEach(function (tarredPackage) {
+                  if (dependencies[tarredPackage]) {
+                    var version = semver.maxSatisfying(_this2.tarredVersions[tarredPackage], dependencies[tarredPackage]);
+
+                    if (version != null) {
+                      packageJson.dependencies[tarredPackage] = "file:".concat(Packleator.PRIVATE_PACKAGES_DIRECTORY).concat(path.sep).concat(tarredPackage.replace('@', '').replace('/', '-'), "-").concat(version, ".tgz");
+                    }
+                  }
+
+                  if (devDependencies[tarredPackage]) {
+                    var _version = semver.maxSatisfying(_this2.tarredVersions[tarredPackage], devDependencies[tarredPackage]);
+
+                    if (_version != null) {
+                      packageJson.devDependencies[tarredPackage] = "file:".concat(Packleator.PRIVATE_PACKAGES_DIRECTORY).concat(path.sep).concat(tarredPackage.replace('@', '').replace('/', '-'), "-").concat(_version, ".tgz");
+                    }
+                  }
+                });
+
+              case 4:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function rebuildPackageJson() {
+        return _rebuildPackageJson.apply(this, arguments);
+      }
+
+      return rebuildPackageJson;
+    }()
+  }, {
+    key: "rebuildPackageLockJson",
+    value: function () {
+      var _rebuildPackageLockJson = _asyncToGenerator(
+      /*#__PURE__*/
+      regeneratorRuntime.mark(function _callee5() {
+        var packageLockJson, tarredPackages, recurseDeps;
+        return regeneratorRuntime.wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                packageLockJson = this.outputPackageLockJson;
+                tarredPackages = Object.keys(this.tarredVersions);
+
+                recurseDeps = function recurseDeps(deps) {
+                  Object.keys(deps).forEach(function (key) {
+                    var dep = deps[key];
+                    tarredPackages.forEach(function (tarredPackage) {
+                      if (key === tarredPackage) {
+                        dep.version = "file:".concat(Packleator.PRIVATE_PACKAGES_DIRECTORY).concat(path.sep).concat(key.replace('@', '').replace('/', '-'), "-").concat(dep.version, ".tgz");
+                        delete dep.resolved;
+                        delete dep.integrity;
+                      }
+
+                      if (dep.requires && dep.requires[tarredPackage]) {
+                        delete dep.requires[tarredPackage];
+                      }
+                    });
+
+                    if (dep.dependencies) {
+                      recurseDeps(dep.dependencies);
+                    }
+                  });
+                };
+
+                recurseDeps(packageLockJson.dependencies);
+
+              case 4:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+
+      function rebuildPackageLockJson() {
+        return _rebuildPackageLockJson.apply(this, arguments);
+      }
+
+      return rebuildPackageLockJson;
+    }()
+  }, {
+    key: "copyFiles",
+    value: function () {
+      var _copyFiles = _asyncToGenerator(
+      /*#__PURE__*/
+      regeneratorRuntime.mark(function _callee6() {
+        var _this3 = this;
+
+        var startsWith, endsWith;
+        return regeneratorRuntime.wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                startsWith = new RegExp("^(dist|lib|image|package|".concat(this.args.output, ")"));
+                endsWith = /\.tgz$/;
+                _context6.next = 4;
+                return fs.remove(this.args.output);
+
+              case 4:
+                _context6.next = 6;
+                return fs.mkdirp(this.args.output);
+
+              case 6:
+                _context6.next = 8;
+                return copy('.', this.args.output, {
+                  overwrite: true,
+                  dot: true,
+                  filter: function filter(item) {
+                    if (item === 'package.json' || item === 'package-lock.json') {
+                      return true;
+                    }
+
+                    if (startsWith.test(item) || endsWith.test(item)) {
+                      return false;
+                    }
+
+                    if (item.startsWith('.') && item.indexOf('.babelrc') === -1) {
+                      return false;
+                    }
+
+                    if (_this3.args.ignore.length > 0) {
+                      return _this3.args.ignore.indexOf(item) === -1;
+                    }
+
+                    return true;
+                  }
+                });
+
+              case 8:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, this);
+      }));
+
+      function copyFiles() {
+        return _copyFiles.apply(this, arguments);
+      }
+
+      return copyFiles;
+    }()
+  }, {
+    key: "pack",
+    value: function () {
+      var _pack = _asyncToGenerator(
+      /*#__PURE__*/
+      regeneratorRuntime.mark(function _callee7(name, version, dir) {
+        var fileName;
+        return regeneratorRuntime.wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                fileName = "".concat(name.replace('@', '').replace('/', '-'), "-").concat(version, ".tgz");
+                _context7.next = 3;
+                return tar.c({
+                  file: fileName,
+                  C: dir,
+                  strict: true,
+                  prefix: 'package/'
+                }, ['.']);
+
+              case 3:
+                _context7.next = 5;
+                return fs.move(path.join(process.cwd(), fileName), path.join(process.cwd(), Packleator.PRIVATE_PACKAGES_DIRECTORY, fileName), {
+                  overwrite: true
+                });
+
+              case 5:
+                if (this.tarredVersions[name]) {
+                  this.tarredVersions[name].push(version);
+                } else {
+                  this.tarredVersions[name] = [version];
+                }
+
+                return _context7.abrupt("return", fileName);
+
+              case 7:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7, this);
+      }));
+
+      function pack(_x4, _x5, _x6) {
+        return _pack.apply(this, arguments);
+      }
+
+      return pack;
+    }()
+  }, {
+    key: "cleanup",
+    value: function () {
+      var _cleanup = _asyncToGenerator(
+      /*#__PURE__*/
+      regeneratorRuntime.mark(function _callee8() {
+        return regeneratorRuntime.wrap(function _callee8$(_context8) {
+          while (1) {
+            switch (_context8.prev = _context8.next) {
+              case 0:
+                _context8.next = 2;
+                return copy(this.args.output, process.cwd(), {
+                  overwrite: true,
+                  filter: '*.tgz'
+                });
+
+              case 2:
+                _context8.next = 4;
+                return fs.remove(this.args.output);
+
+              case 4:
+              case "end":
+                return _context8.stop();
+            }
+          }
+        }, _callee8, this);
+      }));
+
+      function cleanup() {
+        return _cleanup.apply(this, arguments);
+      }
+
+      return cleanup;
+    }()
+  }, {
+    key: "npmInstall",
+    value: function () {
+      var _npmInstall = _asyncToGenerator(
+      /*#__PURE__*/
+      regeneratorRuntime.mark(function _callee9() {
+        var _this4 = this;
+
+        var dir,
+            currentDir,
+            _args9 = arguments;
+        return regeneratorRuntime.wrap(function _callee9$(_context9) {
+          while (1) {
+            switch (_context9.prev = _context9.next) {
+              case 0:
+                dir = _args9.length > 0 && _args9[0] !== undefined ? _args9[0] : process.cwd();
+                currentDir = process.cwd();
+                return _context9.abrupt("return", new Promise(function (resolve, reject) {
+                  if (currentDir !== dir) {
+                    process.chdir(dir);
+                  }
+
+                  var npmInstall = exec('npm install');
+                  npmInstall.stderr.on('data', function (data) {
+                    _this4.stderr += data.toString();
+                  });
+                  npmInstall.on('exit', function (code) {
+                    if (currentDir !== dir) {
+                      process.chdir(currentDir);
+                    }
+
+                    resolve();
+                  });
+                  npmInstall.on('error', function (err) {
+                    if (currentDir !== dir) {
+                      process.chdir(currentDir);
+                    }
+
+                    reject(err);
+                  });
+                }));
+
+              case 3:
+              case "end":
+                return _context9.stop();
+            }
+          }
+        }, _callee9);
+      }));
+
+      function npmInstall() {
+        return _npmInstall.apply(this, arguments);
+      }
+
+      return npmInstall;
+    }()
+  }, {
+    key: "getPrivateDeps",
+    value: function () {
+      var _getPrivateDeps = _asyncToGenerator(
+      /*#__PURE__*/
+      regeneratorRuntime.mark(function _callee10(depth) {
+        var _this5 = this;
+
+        return regeneratorRuntime.wrap(function _callee10$(_context10) {
+          while (1) {
+            switch (_context10.prev = _context10.next) {
+              case 0:
+                return _context10.abrupt("return", new Promise(function (resolve, reject) {
+                  var depthArg = depth != null ? " --depth ".concat(depth) : '';
+                  exec("npm ls --parseable --silent".concat(depthArg), function (err, stdout, stderr) {
+                    if (err && !stdout) {
+                      reject(err);
+                      return;
+                    }
+
+                    var dependencies = stdout.split('\n');
+
+                    if (dependencies) {
+                      resolve(dependencies.filter(function (item) {
+                        var parts = item.split(path.sep);
+                        return _this5.args.namespaces.indexOf(parts[parts.length - 2]) !== -1;
+                      }));
+                    } else {
+                      reject(new Error('Unable to resolve package.json dependencies'));
+                    }
+                  });
+                }));
+
+              case 1:
+              case "end":
+                return _context10.stop();
+            }
+          }
+        }, _callee10);
+      }));
+
+      function getPrivateDeps(_x7) {
+        return _getPrivateDeps.apply(this, arguments);
+      }
+
+      return getPrivateDeps;
+    }()
+  }, {
+    key: "getPackageJson",
+    value: function () {
+      var _getPackageJson = _asyncToGenerator(
+      /*#__PURE__*/
+      regeneratorRuntime.mark(function _callee11() {
+        var dir,
+            lock,
+            lockModifier,
+            file,
+            json,
+            _args11 = arguments;
+        return regeneratorRuntime.wrap(function _callee11$(_context11) {
+          while (1) {
+            switch (_context11.prev = _context11.next) {
+              case 0:
+                dir = _args11.length > 0 && _args11[0] !== undefined ? _args11[0] : process.cwd();
+                lock = _args11.length > 1 && _args11[1] !== undefined ? _args11[1] : false;
+                lockModifier = lock ? '-lock' : '';
+                _context11.prev = 3;
+                _context11.next = 6;
+                return fs.readFile(path.join(dir, "package".concat(lockModifier, ".json")), 'utf-8');
+
+              case 6:
+                file = _context11.sent;
+                json = JSON.parse(file);
+                return _context11.abrupt("return", json);
+
+              case 11:
+                _context11.prev = 11;
+                _context11.t0 = _context11["catch"](3);
+                throw new Error('Error getting package.json. Make sure the current directory contains a valid package.json file');
+
+              case 14:
+              case "end":
+                return _context11.stop();
+            }
+          }
+        }, _callee11, null, [[3, 11]]);
+      }));
+
+      function getPackageJson() {
+        return _getPackageJson.apply(this, arguments);
+      }
+
+      return getPackageJson;
+    }()
+  }]);
+
+  return Packleator;
+}();
+
+_defineProperty(Packleator, "PRIVATE_PACKAGES_DIRECTORY", 'private_packages');
+
+module.exports = Packleator;