@sprucelabs/spruce-cli 19.1.22 → 19.1.24

package/build/features/FeatureInstaller.js

@@ -0,0 +1,690 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FeatureInstallerImpl = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _schema = require("@sprucelabs/schema");
+var _lodash = require("lodash");
+var _merge = _interopRequireDefault(require("lodash/merge"));
+var _SpruceError = _interopRequireDefault(require("../errors/SpruceError"));
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var FeatureInstallerImpl = /*#__PURE__*/function () {
+  function FeatureInstallerImpl(cwd, serviceFactory) {
+    (0, _classCallCheck2["default"])(this, FeatureInstallerImpl);
+    (0, _defineProperty2["default"])(this, "cwd", void 0);
+    (0, _defineProperty2["default"])(this, "featureMap", {});
+    (0, _defineProperty2["default"])(this, "serviceFactory", void 0);
+    (0, _defineProperty2["default"])(this, "featuresMarkedAsSkippedThisRun", []);
+    (0, _defineProperty2["default"])(this, "packagesToInstall", []);
+    (0, _defineProperty2["default"])(this, "devPackagesToInstall", []);
+    (0, _defineProperty2["default"])(this, "featuresToMarkAsInstalled", []);
+    (0, _defineProperty2["default"])(this, "afterPackageInstalls", []);
+    (0, _defineProperty2["default"])(this, "pendingFeatureInstalls", {});
+    this.cwd = cwd;
+    this.serviceFactory = serviceFactory;
+  }
+  (0, _createClass2["default"])(FeatureInstallerImpl, [{
+    key: "isInstalled",
+    value: function () {
+      var _isInstalled = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(code) {
+        var feature;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              feature = this.getFeature(code);
+              if (!feature.isInstalled) {
+                _context.next = 3;
+                break;
+              }
+              return _context.abrupt("return", feature.isInstalled());
+            case 3:
+              return _context.abrupt("return", this.Service('settings').isMarkedAsInstalled(code));
+            case 4:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function isInstalled(_x3) {
+        return _isInstalled.apply(this, arguments);
+      }
+      return isInstalled;
+    }()
+  }, {
+    key: "markAsSkippedThisRun",
+    value: function markAsSkippedThisRun(code) {
+      if (!this.isMarkedAsSkipped(code)) {
+        this.featuresMarkedAsSkippedThisRun.push(code);
+      }
+    }
+  }, {
+    key: "markAsPermanentlySkipped",
+    value: function markAsPermanentlySkipped(code) {
+      if (!this.isMarkedAsSkipped(code)) {
+        this.Service('settings').markAsPermanentlySkipped(code);
+      }
+    }
+  }, {
+    key: "isMarkedAsSkipped",
+    value: function isMarkedAsSkipped(code) {
+      return this.featuresMarkedAsSkippedThisRun.indexOf(code) > -1 || this.Service('settings').isMarkedAsPermanentlySkipped(code);
+    }
+  }, {
+    key: "mapFeature",
+    value: function mapFeature(code, feature) {
+      this.featureMap[code] = feature;
+    }
+  }, {
+    key: "getFeature",
+    value: function getFeature(code) {
+      var feature = this.featureMap[code];
+      if (!feature) {
+        throw new _SpruceError["default"]({
+          code: 'INVALID_FEATURE_CODE',
+          featureCode: code
+        });
+      }
+      return feature;
+    }
+  }, {
+    key: "areInstalled",
+    value: function () {
+      var _areInstalled = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(codes) {
+        var _this = this;
+        var results, i, result;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return Promise.all(codes.map(function (f) {
+                return _this.isInstalled(f);
+              }));
+            case 2:
+              results = _context2.sent;
+              i = 0;
+            case 4:
+              if (!(i < results.length)) {
+                _context2.next = 11;
+                break;
+              }
+              result = results[i];
+              if (result) {
+                _context2.next = 8;
+                break;
+              }
+              return _context2.abrupt("return", false);
+            case 8:
+              i += 1;
+              _context2.next = 4;
+              break;
+            case 11:
+              return _context2.abrupt("return", true);
+            case 12:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }));
+      function areInstalled(_x4) {
+        return _areInstalled.apply(this, arguments);
+      }
+      return areInstalled;
+    }()
+  }, {
+    key: "getFeatureDependencies",
+    value: function getFeatureDependencies(featureCode) {
+      var deps = this.getFeatureDependenciesIncludingSelf({
+        code: featureCode,
+        isRequired: true
+      }, [] // trackedFeatures
+      ).filter(function (f) {
+        return f.code !== featureCode;
+      });
+      deps = this.sortFeatures(deps);
+      return deps;
+    }
+  }, {
+    key: "getFeatureDependenciesIncludingSelf",
+    value: function getFeatureDependenciesIncludingSelf(featureDependency) {
+      var trackedFeatures = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+      var features = [];
+      if (!this.isDependencyInTracker(trackedFeatures, featureDependency)) {
+        features.push(featureDependency);
+        trackedFeatures.push(featureDependency);
+      }
+      var feature = this.getFeature(featureDependency.code);
+      var dependencies = feature.dependencies;
+      for (var i = 0; i < dependencies.length; i += 1) {
+        var dependency = dependencies[i];
+        if (!this.isDependencyInTracker(trackedFeatures, dependency)) {
+          features.push(dependency);
+          trackedFeatures.push(dependency);
+        }
+      }
+      for (var x = 0; x < dependencies.length; x += 1) {
+        var _dependency = dependencies[x];
+        var dependencyDependencies = this.getFeatureDependenciesIncludingSelf(_dependency, trackedFeatures);
+        if (!_dependency.isRequired) {
+          dependencyDependencies = dependencyDependencies.map(function (f) {
+            return _objectSpread(_objectSpread({}, f), {}, {
+              isRequired: false
+            });
+          });
+        }
+        features.push.apply(features, (0, _toConsumableArray2["default"])(dependencyDependencies));
+      }
+      return features;
+    }
+  }, {
+    key: "isDependencyInTracker",
+    value: function isDependencyInTracker(trackedFeatures, dependency) {
+      return !!trackedFeatures.find(function (f) {
+        return f.code === dependency.code;
+      });
+    }
+  }, {
+    key: "install",
+    value: function () {
+      var _install = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(options) {
+        var _this2 = this;
+        var features, _options$installFeatu, installFeatureDependencies, didUpdateHandler, shouldAllowEntertainment, results, dependenciesToInstall, i, _didUpdateHandler, f, _code, _isInstalled2, _didUpdateHandler2, _loop, x, pendingResults;
+        return _regenerator["default"].wrap(function _callee3$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              features = options.features, _options$installFeatu = options.installFeatureDependencies, installFeatureDependencies = _options$installFeatu === void 0 ? true : _options$installFeatu, didUpdateHandler = options.didUpdateHandler;
+              shouldAllowEntertainment = !!features.find(function (f) {
+                return f.code === 'skill';
+              });
+              if (FeatureInstallerImpl.startInFlightIntertainmentHandler && shouldAllowEntertainment) {
+                FeatureInstallerImpl.startInFlightIntertainmentHandler(function (handler) {
+                  didUpdateHandler = handler;
+                });
+              }
+              this.pendingFeatureInstalls = {};
+              results = {};
+              dependenciesToInstall = [];
+              i = 0;
+            case 7:
+              if (!(i < features.length)) {
+                _context4.next = 18;
+                break;
+              }
+              f = features[i];
+              _code = f.code;
+              (_didUpdateHandler = didUpdateHandler) === null || _didUpdateHandler === void 0 || _didUpdateHandler("Checking if ".concat(_code, " is installed..."));
+              _context4.next = 13;
+              return this.isInstalled(_code);
+            case 13:
+              _isInstalled2 = _context4.sent;
+              if (!_isInstalled2 && installFeatureDependencies) {
+                (_didUpdateHandler2 = didUpdateHandler) === null || _didUpdateHandler2 === void 0 || _didUpdateHandler2("It is not, checking dependencies...");
+                dependenciesToInstall = dependenciesToInstall.concat(this.getFeatureDependenciesIncludingSelf({
+                  code: _code,
+                  isRequired: true
+                }));
+              } else if (!_isInstalled2) {
+                dependenciesToInstall.push({
+                  code: _code,
+                  isRequired: true
+                });
+              }
+            case 15:
+              i += 1;
+              _context4.next = 7;
+              break;
+            case 18:
+              dependenciesToInstall = (0, _lodash.uniq)(dependenciesToInstall);
+              dependenciesToInstall = this.sortFeatures(dependenciesToInstall);
+              _loop = /*#__PURE__*/_regenerator["default"].mark(function _loop() {
+                var _dependenciesToInstal, code, isRequired, isInstalled, _options$features$fin, _didUpdateHandler3, installOptions, installFeature, installResults;
+                return _regenerator["default"].wrap(function _loop$(_context3) {
+                  while (1) switch (_context3.prev = _context3.next) {
+                    case 0:
+                      _dependenciesToInstal = dependenciesToInstall[x], code = _dependenciesToInstal.code, isRequired = _dependenciesToInstal.isRequired;
+                      _context3.next = 3;
+                      return _this2.isInstalledOrPendingInstall(code);
+                    case 3:
+                      isInstalled = _context3.sent;
+                      if (!(!isInstalled && isRequired)) {
+                        _context3.next = 12;
+                        break;
+                      }
+                      installOptions = //@ts-ignore
+                      (_options$features$fin = options.features.find(function (f) {
+                        return f.code === code;
+                      })) === null || _options$features$fin === void 0 ? void 0 : _options$features$fin.options;
+                      installFeature = {
+                        code: code,
+                        options: installOptions
+                      };
+                      (_didUpdateHandler3 = didUpdateHandler) === null || _didUpdateHandler3 === void 0 || _didUpdateHandler3("Installing the ".concat(installFeature.code, " feature...."));
+                      _context3.next = 10;
+                      return _this2.installFeature(installFeature, didUpdateHandler);
+                    case 10:
+                      installResults = _context3.sent;
+                      results = (0, _merge["default"])(results, installResults);
+                    case 12:
+                    case "end":
+                      return _context3.stop();
+                  }
+                }, _loop);
+              });
+              x = 0;
+            case 22:
+              if (!(x < dependenciesToInstall.length)) {
+                _context4.next = 27;
+                break;
+              }
+              return _context4.delegateYield(_loop(), "t0", 24);
+            case 24:
+              x += 1;
+              _context4.next = 22;
+              break;
+            case 27:
+              _context4.next = 29;
+              return this.installAllPending(didUpdateHandler);
+            case 29:
+              pendingResults = _context4.sent;
+              results = (0, _merge["default"])(results, pendingResults);
+              if (FeatureInstallerImpl.stopInFlightIntertainmentHandler && shouldAllowEntertainment) {
+                FeatureInstallerImpl.stopInFlightIntertainmentHandler();
+              }
+              return _context4.abrupt("return", results);
+            case 33:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee3, this);
+      }));
+      function install(_x5) {
+        return _install.apply(this, arguments);
+      }
+      return install;
+    }()
+  }, {
+    key: "isInstalledOrPendingInstall",
+    value: function isInstalledOrPendingInstall(code) {
+      return this.pendingFeatureInstalls[code] || this.isInstalled(code);
+    }
+  }, {
+    key: "installFeature",
+    value: function () {
+      var _installFeature2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(_installFeature, didUpdateHandler) {
+        var _beforeInstallResults;
+        var feature, _installFeature$optio, beforeInstallResults, packagesInstalled, files;
+        return _regenerator["default"].wrap(function _callee4$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              this.pendingFeatureInstalls[_installFeature.code] = true;
+              feature = this.getFeature(_installFeature.code);
+              if (feature.optionsSchema) {
+                //@ts-ignore
+                (0, _schema.validateSchemaValues)(feature.optionsSchema, (_installFeature$optio = _installFeature.options) !== null && _installFeature$optio !== void 0 ? _installFeature$optio : {});
+              }
+              didUpdateHandler === null || didUpdateHandler === void 0 || didUpdateHandler("Running before package install hook...");
+              _context5.next = 6;
+              return feature.beforePackageInstall(
+              //@ts-ignore
+              _installFeature.options);
+            case 6:
+              beforeInstallResults = _context5.sent;
+              if (beforeInstallResults.cwd) {
+                this.cwd = beforeInstallResults.cwd;
+              }
+              didUpdateHandler === null || didUpdateHandler === void 0 || didUpdateHandler("Installing package dependencies...");
+              _context5.next = 11;
+              return this.queueInstallPackageDependenciesWithoutEntertainment(feature, didUpdateHandler);
+            case 11:
+              packagesInstalled = _context5.sent;
+              didUpdateHandler === null || didUpdateHandler === void 0 || didUpdateHandler("Running after package install hook...");
+              this.afterPackageInstalls.push(_installFeature);
+              if (!feature.isInstalled) {
+                this.featuresToMarkAsInstalled.push(feature.code);
+              }
+              files = (0, _toConsumableArray2["default"])((_beforeInstallResults = beforeInstallResults.files) !== null && _beforeInstallResults !== void 0 ? _beforeInstallResults : []);
+              return _context5.abrupt("return", {
+                files: files !== null && files !== void 0 ? files : undefined,
+                packagesInstalled: packagesInstalled
+              });
+            case 17:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee4, this);
+      }));
+      function installFeature(_x6, _x7) {
+        return _installFeature2.apply(this, arguments);
+      }
+      return installFeature;
+    }()
+  }, {
+    key: "installPackageDependencies",
+    value: function () {
+      var _installPackageDependencies = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5(feature, didUpdateHandler) {
+        return _regenerator["default"].wrap(function _callee5$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              return _context6.abrupt("return", this.installPackageDependenciesForFeatures([feature], didUpdateHandler));
+            case 1:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee5, this);
+      }));
+      function installPackageDependencies(_x8, _x9) {
+        return _installPackageDependencies.apply(this, arguments);
+      }
+      return installPackageDependencies;
+    }()
+  }, {
+    key: "installPackageDependenciesForFeatures",
+    value: function () {
+      var _installPackageDependenciesForFeatures = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6(features, didUpdateHandler) {
+        var _iterator, _step, _feature;
+        return _regenerator["default"].wrap(function _callee6$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              if (FeatureInstallerImpl.startInFlightIntertainmentHandler) {
+                FeatureInstallerImpl.startInFlightIntertainmentHandler(function (handler) {
+                  didUpdateHandler = handler;
+                });
+              }
+              _iterator = _createForOfIteratorHelper(features);
+              _context7.prev = 2;
+              _iterator.s();
+            case 4:
+              if ((_step = _iterator.n()).done) {
+                _context7.next = 10;
+                break;
+              }
+              _feature = _step.value;
+              _context7.next = 8;
+              return this.queueInstallPackageDependenciesWithoutEntertainment(_feature, didUpdateHandler);
+            case 8:
+              _context7.next = 4;
+              break;
+            case 10:
+              _context7.next = 15;
+              break;
+            case 12:
+              _context7.prev = 12;
+              _context7.t0 = _context7["catch"](2);
+              _iterator.e(_context7.t0);
+            case 15:
+              _context7.prev = 15;
+              _iterator.f();
+              return _context7.finish(15);
+            case 18:
+              _context7.next = 20;
+              return this.installAllPending(didUpdateHandler);
+            case 20:
+              if (FeatureInstallerImpl.stopInFlightIntertainmentHandler) {
+                FeatureInstallerImpl.stopInFlightIntertainmentHandler();
+              }
+            case 21:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee6, this, [[2, 12, 15, 18]]);
+      }));
+      function installPackageDependenciesForFeatures(_x10, _x11) {
+        return _installPackageDependenciesForFeatures.apply(this, arguments);
+      }
+      return installPackageDependenciesForFeatures;
+    }()
+  }, {
+    key: "installAllPending",
+    value: function () {
+      var _installAllPending = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7(didUpdateHandler) {
+        var pkgService, settings, _iterator2, _step2, _code2, results, _iterator3, _step3, installFeature, _feature2, afterInstallResults;
+        return _regenerator["default"].wrap(function _callee7$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              pkgService = this.Service('pkg');
+              if (!(this.packagesToInstall.length > 0)) {
+                _context8.next = 5;
+                break;
+              }
+              didUpdateHandler === null || didUpdateHandler === void 0 || didUpdateHandler("Installing ".concat(this.packagesToInstall.length, " node module").concat(this.packagesToInstall.length === 1 ? '' : 's', ". Please be patient."));
+              _context8.next = 5;
+              return pkgService.install(this.packagesToInstall, {});
+            case 5:
+              if (!(this.devPackagesToInstall.length > 0)) {
+                _context8.next = 9;
+                break;
+              }
+              didUpdateHandler === null || didUpdateHandler === void 0 || didUpdateHandler("Now installing ".concat(this.devPackagesToInstall.length, " DEV node module").concat(this.devPackagesToInstall.length === 1 ? '' : 's', ". Please be patient."));
+              _context8.next = 9;
+              return pkgService.install(this.devPackagesToInstall, {
+                isDev: true
+              });
+            case 9:
+              this.packagesToInstall = [];
+              this.devPackagesToInstall = [];
+              settings = this.Service('settings');
+              _iterator2 = _createForOfIteratorHelper(this.featuresToMarkAsInstalled);
+              try {
+                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                  _code2 = _step2.value;
+                  settings.markAsInstalled(_code2);
+                }
+              } catch (err) {
+                _iterator2.e(err);
+              } finally {
+                _iterator2.f();
+              }
+              this.featuresToMarkAsInstalled = [];
+              results = {};
+              _iterator3 = _createForOfIteratorHelper(this.afterPackageInstalls);
+              _context8.prev = 17;
+              _iterator3.s();
+            case 19:
+              if ((_step3 = _iterator3.n()).done) {
+                _context8.next = 28;
+                break;
+              }
+              installFeature = _step3.value;
+              _feature2 = this.getFeature(installFeature.code);
+              _context8.next = 24;
+              return _feature2.afterPackageInstall(
+              //@ts-ignore
+              installFeature.options);
+            case 24:
+              afterInstallResults = _context8.sent;
+              results = (0, _merge["default"])(results, afterInstallResults);
+            case 26:
+              _context8.next = 19;
+              break;
+            case 28:
+              _context8.next = 33;
+              break;
+            case 30:
+              _context8.prev = 30;
+              _context8.t0 = _context8["catch"](17);
+              _iterator3.e(_context8.t0);
+            case 33:
+              _context8.prev = 33;
+              _iterator3.f();
+              return _context8.finish(33);
+            case 36:
+              return _context8.abrupt("return", results);
+            case 37:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee7, this, [[17, 30, 33, 36]]);
+      }));
+      function installAllPending(_x12) {
+        return _installAllPending.apply(this, arguments);
+      }
+      return installAllPending;
+    }()
+  }, {
+    key: "queueInstallPackageDependenciesWithoutEntertainment",
+    value: function () {
+      var _queueInstallPackageDependenciesWithoutEntertainment = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee8(feature, didUpdateHandler) {
+        var _feature$packageDepen,
+          _this3 = this;
+        var packagesInstalled, pkgService;
+        return _regenerator["default"].wrap(function _callee8$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              packagesInstalled = [];
+              pkgService = this.Service('pkg');
+              (_feature$packageDepen = feature.packageDependencies) === null || _feature$packageDepen === void 0 || _feature$packageDepen.forEach(function (pkg) {
+                var packageName = pkgService.buildPackageName(pkg);
+                packagesInstalled.push(pkg);
+                didUpdateHandler === null || didUpdateHandler === void 0 || didUpdateHandler("Checking node dependency: ".concat(pkg.name));
+                if (pkg.isDev && _this3.devPackagesToInstall.indexOf(packageName) === -1) {
+                  _this3.devPackagesToInstall.push(packageName);
+                } else if (!pkg.isDev && _this3.packagesToInstall.indexOf(packageName) === -1) {
+                  _this3.packagesToInstall.push(packageName);
+                }
+              });
+              if (this.packagesToInstall.length > 0) {
+                didUpdateHandler === null || didUpdateHandler === void 0 || didUpdateHandler("Queueing install of ".concat(this.packagesToInstall.length, " node dependenc").concat(this.packagesToInstall.length === 1 ? 'y.' : 'ies for ' + this.getFeatureNameAndDesc(feature) + '...', "."));
+              }
+              if (this.devPackagesToInstall.length > 0) {
+                didUpdateHandler === null || didUpdateHandler === void 0 || didUpdateHandler("Queueing install of ".concat(this.devPackagesToInstall.length, " DEV node dependenc").concat(this.devPackagesToInstall.length === 1 ? 'y.' : 'ies for ' + this.getFeatureNameAndDesc(feature) + '. 🤘', "."));
+              }
+              return _context9.abrupt("return", packagesInstalled);
+            case 6:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee8, this);
+      }));
+      function queueInstallPackageDependenciesWithoutEntertainment(_x13, _x14) {
+        return _queueInstallPackageDependenciesWithoutEntertainment.apply(this, arguments);
+      }
+      return queueInstallPackageDependenciesWithoutEntertainment;
+    }()
+  }, {
+    key: "getFeatureNameAndDesc",
+    value: function getFeatureNameAndDesc(feature) {
+      return "".concat(feature.nameReadable).concat(feature.description ? ' (' + feature.description + ')' : '');
+    }
+  }, {
+    key: "sortFeatures",
+    value: function sortFeatures(featureDependencies) {
+      var _this4 = this;
+      return (0, _toConsumableArray2["default"])(featureDependencies).sort(function (a, b) {
+        var aFeature = _this4.getFeature(a.code);
+        var bFeature = _this4.getFeature(b.code);
+        var aDependsOnB = aFeature.dependencies.find(function (d) {
+          return d.code === b.code;
+        });
+        var bDependsOnA = bFeature.dependencies.find(function (d) {
+          return d.code === a.code;
+        });
+        if (aDependsOnB || aFeature.installOrderWeight < bFeature.installOrderWeight) {
+          return 1;
+        } else if (bDependsOnA || aFeature.installOrderWeight > bFeature.installOrderWeight) {
+          return -1;
+        }
+        return 0;
+      });
+    }
+  }, {
+    key: "Service",
+    value: function (_Service) {
+      function Service(_x, _x2) {
+        return _Service.apply(this, arguments);
+      }
+      Service.toString = function () {
+        return _Service.toString();
+      };
+      return Service;
+    }(function (type, cwd) {
+      return this.serviceFactory.Service(cwd !== null && cwd !== void 0 ? cwd : this.cwd, type);
+    })
+  }, {
+    key: "getOptionsForFeature",
+    value: function getOptionsForFeature(code) {
+      return this.getFeature(code).optionsSchema;
+    }
+  }, {
+    key: "getAllCodes",
+    value: function getAllCodes() {
+      var codes = Object.keys(this.featureMap);
+      return this.sortFeatures(codes.map(function (code) {
+        return {
+          code: code,
+          isRequired: true
+        };
+      })).map(function (dep) {
+        return dep.code;
+      });
+    }
+  }, {
+    key: "getInstalledFeatures",
+    value: function () {
+      var _getInstalledFeatures = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee10() {
+        var _this5 = this;
+        var installed;
+        return _regenerator["default"].wrap(function _callee10$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              _context11.next = 2;
+              return Promise.all(this.getAllCodes().map( /*#__PURE__*/function () {
+                var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9(code) {
+                  var isInstalled;
+                  return _regenerator["default"].wrap(function _callee9$(_context10) {
+                    while (1) switch (_context10.prev = _context10.next) {
+                      case 0:
+                        _context10.next = 2;
+                        return _this5.isInstalled(code);
+                      case 2:
+                        isInstalled = _context10.sent;
+                        if (!isInstalled) {
+                          _context10.next = 5;
+                          break;
+                        }
+                        return _context10.abrupt("return", _this5.getFeature(code));
+                      case 5:
+                        return _context10.abrupt("return", false);
+                      case 6:
+                      case "end":
+                        return _context10.stop();
+                    }
+                  }, _callee9);
+                }));
+                return function (_x15) {
+                  return _ref.apply(this, arguments);
+                };
+              }()));
+            case 2:
+              installed = _context11.sent;
+              return _context11.abrupt("return", installed.filter(function (f) {
+                return !!f;
+              }));
+            case 4:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee10, this);
+      }));
+      function getInstalledFeatures() {
+        return _getInstalledFeatures.apply(this, arguments);
+      }
+      return getInstalledFeatures;
+    }()
+  }]);
+  return FeatureInstallerImpl;
+}();
+exports.FeatureInstallerImpl = FeatureInstallerImpl;
+(0, _defineProperty2["default"])(FeatureInstallerImpl, "startInFlightIntertainmentHandler", void 0);
+(0, _defineProperty2["default"])(FeatureInstallerImpl, "stopInFlightIntertainmentHandler", void 0);
+//# sourceMappingURL=FeatureInstaller.js.map