@atlaskit/dependency-version-analytics 1.1.0 → 1.2.1

package/dist/cjs/commands/populate-historic-data/lib/dependency-store.js

@@ -5,13 +5,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.DependencyStore = void 0;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-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 _debug = _interopRequireDefault(require("debug"));
 var _semver = _interopRequireDefault(require("semver"));
 var _yarn = require("../../../util/yarn");
@@ -19,477 +12,260 @@ var _git = require("../../../util/git");
 var _constants = require("../../../constants");
 var _assert = require("../../../util/assert");
 var _micromatch = _interopRequireDefault(require("micromatch"));
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-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; }
-var debug = (0, _debug.default)('atlaskit:dependency');
+var _allowedScopes = require("../util/allowed-scopes");
+/** Workspace code */
+
+const debug = (0, _debug.default)('atlaskit:dependency');
 /**
  * Stores the state of atlaskit dependencies in a repository
  */
-var DependencyStore = /*#__PURE__*/function () {
+class DependencyStore {
   /** Mapping of dependency names to arrays of unique dependency type + versions */
-
+  dependencies = {};
   /** Mapping of workspaces to their dependency map. Each dependency in their map links to an entry in `dependencies` */
-
+  workspaces = {};
   /** Set of workspace globs. Used to verify that a package.json is a valid workspace */
-
-  function DependencyStore() {
-    var cwd = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : process.cwd();
-    (0, _classCallCheck2.default)(this, DependencyStore);
-    (0, _defineProperty2.default)(this, "dependencies", {});
-    (0, _defineProperty2.default)(this, "workspaces", {});
-    (0, _defineProperty2.default)(this, "workspaceGlobs", new Set());
-    (0, _defineProperty2.default)(this, "initialised", false);
+  workspaceGlobs = new Set();
+  initialised = false;
+  constructor(cwd = process.cwd(), supportedScopes) {
     this.cwd = cwd;
+    this.supportedScopes = supportedScopes;
   }
 
   /** Scans the repo for dependencies at the specified git ref and return the flattened dependency map */
-  (0, _createClass2.default)(DependencyStore, [{
-    key: "initialise",
-    value: function () {
-      var _initialise = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(gitRef) {
-        return _regenerator.default.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                if (!gitRef) {
-                  _context.next = 3;
-                  break;
-                }
-                _context.next = 3;
-                return this.resetStore(gitRef);
-              case 3:
-                this.initialised = true;
-                return _context.abrupt("return", this.getFlattenedDeps());
-              case 5:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this);
-      }));
-      function initialise(_x) {
-        return _initialise.apply(this, arguments);
-      }
-      return initialise;
-    }()
-    /** Updates the repo dependency store based on the changes in `logItem`.
-     * Returns the updated flattened dependencies
-     */
-  }, {
-    key: "update",
-    value: function () {
-      var _update = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(logItem) {
-        var hash, changedPackageJsons, didRootPackageJsonChange, workspaceGlobs, globsChanged, changedWorkspaces, _iterator, _step, workspacePath, workspaceDeps, validWorkspace, noLongerWorkspace;
-        return _regenerator.default.wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                this.assertInitialised();
-                hash = logItem.hash;
-                (0, _assert.assert)(!!logItem.diff, "Diff must exist in log ".concat(logItem, " ").concat(hash));
-                changedPackageJsons = logItem.diff.files.filter(function (f) {
-                  return f.file === 'package.json' || f.file.endsWith('/package.json');
-                }).map(function (f) {
-                  return f.file;
-                });
-                didRootPackageJsonChange = !!changedPackageJsons.find(function (file) {
-                  return file === 'package.json';
-                });
-                if (!didRootPackageJsonChange) {
-                  _context2.next = 15;
-                  break;
-                }
-                _context2.next = 8;
-                return (0, _yarn.getWorkspaceGlobs)(hash, this.cwd);
-              case 8:
-                workspaceGlobs = _context2.sent;
-                globsChanged = workspaceGlobs !== null && (this.workspaceGlobs.size !== workspaceGlobs.size || (0, _toConsumableArray2.default)(this.workspaceGlobs).some(function (glob) {
-                  return !workspaceGlobs.has(glob);
-                }));
-                if (!globsChanged) {
-                  _context2.next = 15;
-                  break;
-                }
-                debug("Workspace globs changed: ".concat((0, _toConsumableArray2.default)(workspaceGlobs), ". Resetting store."));
-                _context2.next = 14;
-                return this.resetStore(hash);
-              case 14:
-                return _context2.abrupt("return", this.getFlattenedDeps());
-              case 15:
-                changedWorkspaces = (0, _micromatch.default)(changedPackageJsons, (0, _toConsumableArray2.default)(this.workspaceGlobs));
-                debug("Updating changed workspaces@".concat(hash, ": ").concat(changedWorkspaces));
-
-                // Iterate over all changed package.jsons rather than only valid workspaces so that we can
-                // remove older workspaces that are no longer valid
-                _iterator = _createForOfIteratorHelper(changedPackageJsons);
-                _context2.prev = 18;
-                _iterator.s();
-              case 20:
-                if ((_step = _iterator.n()).done) {
-                  _context2.next = 33;
-                  break;
-                }
-                workspacePath = _step.value;
-                _context2.next = 24;
-                return this.getWorkspaceDependencies(hash, workspacePath);
-              case 24:
-                workspaceDeps = _context2.sent;
-                validWorkspace = changedWorkspaces.includes(workspacePath);
-                if (!(!validWorkspace && !this.workspaces[workspacePath])) {
-                  _context2.next = 28;
-                  break;
-                }
-                return _context2.abrupt("continue", 31);
-              case 28:
-                // For workspaces that are no longer a valid workspace but were previously, explicitly remove them
-                noLongerWorkspace = !validWorkspace && this.workspaces[workspacePath];
-                if (workspaceDeps == null || noLongerWorkspace) {
-                  // If workspaceDeps is undefined, package.json existed but JSON was invalid
-                  // Else if workspaceDeps is null, package.json doesn't exist and has hence been deleted
-                  if (workspaceDeps === undefined) {
-                    console.error("Error parsing metadata for workspace ".concat(workspacePath, "@").concat(hash));
-                  }
-                  // set the workspaceDeps to empty here explicitly to remove any deleted workspaces
-                  workspaceDeps = {};
-                }
-                this.updateWorkspaces(workspacePath, workspaceDeps);
-              case 31:
-                _context2.next = 20;
-                break;
-              case 33:
-                _context2.next = 38;
-                break;
-              case 35:
-                _context2.prev = 35;
-                _context2.t0 = _context2["catch"](18);
-                _iterator.e(_context2.t0);
-              case 38:
-                _context2.prev = 38;
-                _iterator.f();
-                return _context2.finish(38);
-              case 41:
-                return _context2.abrupt("return", this.getFlattenedDeps());
-              case 42:
-              case "end":
-                return _context2.stop();
-            }
-          }
-        }, _callee2, this, [[18, 35, 38, 41]]);
-      }));
-      function update(_x2) {
-        return _update.apply(this, arguments);
-      }
-      return update;
-    }()
-    /** Retrieve a flattened list of p repo dependencies.
-     * If multiple versions of a dependency exist, the lowest version is returned.
-     * If the dependency is listed under multiple dependency types, 'dependencies' is prioritised over 'devDependencies'
-     */
-  }, {
-    key: "getFlattenedDeps",
-    value: function getFlattenedDeps() {
-      var deps = Object.entries(this.dependencies).filter(function (_ref) {
-        var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
-          versions = _ref2[1];
-        return versions.length > 0;
-      }).map(function (_ref3) {
-        var _ref4 = (0, _slicedToArray2.default)(_ref3, 2),
-          depName = _ref4[0],
-          versions = _ref4[1];
-        return [depName, DependencyStore.getMinimumVersion(versions, depName)];
-      });
-      return fromEntries(deps);
+  async initialise(gitRef) {
+    if (gitRef) {
+      await this.resetStore(gitRef);
     }
-  }, {
-    key: "assertInitialised",
-    value: function assertInitialised() {
-      if (!this.initialised) {
-        throw new Error('Class must be initialised first with `.initialise()`');
+    this.initialised = true;
+    return this.getFlattenedDeps();
+  }
+
+  /** Updates the repo dependency store based on the changes in `logItem`.
+   * Returns the updated flattened dependencies
+   */
+  async update(logItem) {
+    this.assertInitialised();
+    const hash = logItem.hash;
+    (0, _assert.assert)(!!logItem.diff, `Diff must exist in log ${logItem} ${hash}`);
+    const changedPackageJsons = logItem.diff.files.filter(f => f.file === 'package.json' || f.file.endsWith('/package.json')).map(f => f.file);
+    const didRootPackageJsonChange = !!changedPackageJsons.find(file => file === 'package.json');
+    if (didRootPackageJsonChange) {
+      const workspaceGlobs = await (0, _yarn.getWorkspaceGlobs)(hash, this.cwd);
+      const globsChanged = workspaceGlobs !== null && (this.workspaceGlobs.size !== workspaceGlobs.size || [...this.workspaceGlobs].some(glob => !workspaceGlobs.has(glob)));
+      if (globsChanged) {
+        debug(`Workspace globs changed: ${[...workspaceGlobs]}. Resetting store.`);
+        await this.resetStore(hash);
+        return this.getFlattenedDeps();
       }
     }
+    const changedWorkspaces = (0, _micromatch.default)(changedPackageJsons, [...this.workspaceGlobs]);
+    debug(`Updating changed workspaces@${hash}: ${changedWorkspaces}`);
 
-    /** Scans all workspaces in repo and rebuilds dependency store */
-  }, {
-    key: "resetStore",
-    value: function () {
-      var _resetStore = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(gitRef) {
-        var workspaceGlobs, workspacePaths, _iterator2, _step2, wsPath, workspaceDeps;
-        return _regenerator.default.wrap(function _callee3$(_context3) {
-          while (1) {
-            switch (_context3.prev = _context3.next) {
-              case 0:
-                this.dependencies = {};
-                this.workspaces = {};
-                _context3.next = 4;
-                return (0, _yarn.getWorkspaceGlobs)(gitRef, this.cwd);
-              case 4:
-                workspaceGlobs = _context3.sent;
-                if (workspaceGlobs !== null) {
-                  this.workspaceGlobs = workspaceGlobs;
-                }
-                _context3.next = 8;
-                return (0, _yarn.getWorkspacePaths)(gitRef, this.workspaceGlobs, this.cwd);
-              case 8:
-                workspacePaths = _context3.sent;
-                debug("Workspace paths: ".concat(workspacePaths));
-                _iterator2 = _createForOfIteratorHelper(workspacePaths);
-                _context3.prev = 11;
-                _iterator2.s();
-              case 13:
-                if ((_step2 = _iterator2.n()).done) {
-                  _context3.next = 25;
-                  break;
-                }
-                wsPath = _step2.value;
-                if (!this.workspaces[wsPath]) {
-                  _context3.next = 17;
-                  break;
-                }
-                throw new Error("Duplicate workspace path found: ".concat(wsPath));
-              case 17:
-                _context3.next = 19;
-                return this.getWorkspaceDependencies(gitRef, wsPath);
-              case 19:
-                workspaceDeps = _context3.sent;
-                if (!(workspaceDeps == null)) {
-                  _context3.next = 22;
-                  break;
-                }
-                return _context3.abrupt("continue", 23);
-              case 22:
-                this.updateWorkspaces(wsPath, workspaceDeps);
-              case 23:
-                _context3.next = 13;
-                break;
-              case 25:
-                _context3.next = 30;
-                break;
-              case 27:
-                _context3.prev = 27;
-                _context3.t0 = _context3["catch"](11);
-                _iterator2.e(_context3.t0);
-              case 30:
-                _context3.prev = 30;
-                _iterator2.f();
-                return _context3.finish(30);
-              case 33:
-              case "end":
-                return _context3.stop();
-            }
-          }
-        }, _callee3, this, [[11, 27, 30, 33]]);
-      }));
-      function resetStore(_x3) {
-        return _resetStore.apply(this, arguments);
+    // Iterate over all changed package.jsons rather than only valid workspaces so that we can
+    // remove older workspaces that are no longer valid
+    for (const workspacePath of changedPackageJsons) {
+      let workspaceDeps = await this.getWorkspaceDependencies(hash, workspacePath);
+      const validWorkspace = changedWorkspaces.includes(workspacePath);
+      if (!validWorkspace && !this.workspaces[workspacePath]) {
+        // Ignore package.jsons that aren't a valid workspace and weren't valid previously
+        continue;
       }
-      return resetStore;
-    }()
-  }, {
-    key: "getWorkspaceDependencies",
-    value: function () {
-      var _getWorkspaceDependencies = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(hash, workspacePath) {
-        var file, json, workspaceDeps, _iterator3, _step3, _step3$value, packageJsonKey, depTypeName, wsDeps;
-        return _regenerator.default.wrap(function _callee4$(_context4) {
-          while (1) {
-            switch (_context4.prev = _context4.next) {
-              case 0:
-                _context4.prev = 0;
-                _context4.next = 3;
-                return (0, _git.showFile)(hash, workspacePath, {
-                  cwd: this.cwd
-                });
-              case 3:
-                file = _context4.sent;
-                _context4.next = 10;
-                break;
-              case 6:
-                _context4.prev = 6;
-                _context4.t0 = _context4["catch"](0);
-                debug("Could not show file ".concat(workspacePath, "@").concat(hash));
-                return _context4.abrupt("return", null);
-              case 10:
-                _context4.prev = 10;
-                json = JSON.parse(file);
-                _context4.next = 18;
-                break;
-              case 14:
-                _context4.prev = 14;
-                _context4.t1 = _context4["catch"](10);
-                console.error("Error parsing JSON - \"".concat(file, "\"@").concat(hash));
-                return _context4.abrupt("return", undefined);
-              case 18:
-                workspaceDeps = {};
-                _iterator3 = _createForOfIteratorHelper(_constants.DEP_TYPES);
-                try {
-                  for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-                    _step3$value = _step3.value, packageJsonKey = _step3$value.packageJsonKey, depTypeName = _step3$value.depTypeName;
-                    wsDeps = DependencyStore.getAkDependencies(json[packageJsonKey] || {}, depTypeName);
-                    workspaceDeps = _objectSpread(_objectSpread({}, workspaceDeps), wsDeps);
-                  }
-                } catch (err) {
-                  _iterator3.e(err);
-                } finally {
-                  _iterator3.f();
-                }
-                return _context4.abrupt("return", workspaceDeps);
-              case 22:
-              case "end":
-                return _context4.stop();
-            }
-          }
-        }, _callee4, this, [[0, 6], [10, 14]]);
-      }));
-      function getWorkspaceDependencies(_x4, _x5) {
-        return _getWorkspaceDependencies.apply(this, arguments);
-      }
-      return getWorkspaceDependencies;
-    }()
-  }, {
-    key: "updateWorkspaces",
-    value: function updateWorkspaces(workspacePath, workspaceDeps) {
-      debug("Updating workspace ".concat(workspacePath));
-      if (!this.workspaces[workspacePath]) {
-        this.workspaces[workspacePath] = {};
-      }
-      var prevWorkspaceDeps = this.workspaces[workspacePath];
-      for (var _i = 0, _Object$keys = Object.keys(prevWorkspaceDeps); _i < _Object$keys.length; _i++) {
-        var depName = _Object$keys[_i];
-        if (!workspaceDeps[depName]) {
-          this.removeDependency(workspacePath, depName, prevWorkspaceDeps[depName]);
+
+      // For workspaces that are no longer a valid workspace but were previously, explicitly remove them
+      const noLongerWorkspace = !validWorkspace && this.workspaces[workspacePath];
+      if (workspaceDeps == null || noLongerWorkspace) {
+        // If workspaceDeps is undefined, package.json existed but JSON was invalid
+        // Else if workspaceDeps is null, package.json doesn't exist and has hence been deleted
+        if (workspaceDeps === undefined) {
+          console.error(`Error parsing metadata for workspace ${workspacePath}@${hash}`);
         }
+        // set the workspaceDeps to empty here explicitly to remove any deleted workspaces
+        workspaceDeps = {};
       }
-      for (var _i2 = 0, _Object$entries = Object.entries(workspaceDeps); _i2 < _Object$entries.length; _i2++) {
-        var _Object$entries$_i = (0, _slicedToArray2.default)(_Object$entries[_i2], 2),
-          _depName = _Object$entries$_i[0],
-          _Object$entries$_i$ = _Object$entries$_i[1],
-          version = _Object$entries$_i$.version,
-          type = _Object$entries$_i$.type;
-        this.addDependency(workspacePath, _depName, version, type);
-      }
+      this.updateWorkspaces(workspacePath, workspaceDeps);
     }
-  }, {
-    key: "addDependency",
-    value: function addDependency(workspacePath, depName, version, type) {
-      if (!this.dependencies[depName]) {
-        debug("Adding new dep ".concat(depName));
-        this.dependencies[depName] = [];
-      }
-      var prevEntry = this.workspaces[workspacePath][depName];
-      var existingEntry = this.dependencies[depName].find(function (entry) {
-        return entry.version === version && entry.type === type;
-      });
-      if (existingEntry && existingEntry === prevEntry) {
-        // We haven't added or updated the dep, exit early
-        return;
-      }
-      if (prevEntry) {
-        this.removeDependency(workspacePath, depName, prevEntry);
+    return this.getFlattenedDeps();
+  }
+
+  /** Retrieve a flattened list of p repo dependencies.
+   * If multiple versions of a dependency exist, the lowest version is returned.
+   * If the dependency is listed under multiple dependency types, 'dependencies' is prioritised over 'devDependencies'
+   */
+  getFlattenedDeps() {
+    const deps = Object.entries(this.dependencies).filter(([, versions]) => versions.length > 0).map(([depName, versions]) => [depName, DependencyStore.getMinimumVersion(versions, depName)]);
+    return fromEntries(deps);
+  }
+  assertInitialised() {
+    if (!this.initialised) {
+      throw new Error('Class must be initialised first with `.initialise()`');
+    }
+  }
+
+  /** Scans all workspaces in repo and rebuilds dependency store */
+  async resetStore(gitRef) {
+    this.dependencies = {};
+    this.workspaces = {};
+    const workspaceGlobs = await (0, _yarn.getWorkspaceGlobs)(gitRef, this.cwd);
+    if (workspaceGlobs !== null) {
+      this.workspaceGlobs = workspaceGlobs;
+    }
+    const workspacePaths = await (0, _yarn.getWorkspacePaths)(gitRef, this.workspaceGlobs, this.cwd);
+    debug(`Workspace paths: ${workspacePaths}`);
+    for (const wsPath of workspacePaths) {
+      if (this.workspaces[wsPath]) {
+        throw new Error(`Duplicate workspace path found: ${wsPath}`);
       }
-      if (existingEntry) {
-        existingEntry.workspaces.add(workspacePath);
-        this.workspaces[workspacePath][depName] = existingEntry;
-      } else {
-        debug("Adding new dependency version ".concat(depName, "@").concat(version, " (").concat(type, ")"));
-        var newEntry = {
-          version: version,
-          type: type,
-          workspaces: new Set([workspacePath])
-        };
-        this.dependencies[depName].push(newEntry);
-        this.workspaces[workspacePath][depName] = newEntry;
+      const workspaceDeps = await this.getWorkspaceDependencies(gitRef, wsPath);
+      if (workspaceDeps == null) {
+        continue;
       }
+      this.updateWorkspaces(wsPath, workspaceDeps);
     }
-  }, {
-    key: "removeDependency",
-    value: function removeDependency(workspacePath, depName, depEntry) {
-      debug("".concat(depName, " removed from ").concat(workspacePath));
-      (0, _assert.assert)(depEntry && depEntry.workspaces, "Dep entry should exist for ".concat(depName));
-      depEntry.workspaces.delete(workspacePath);
-      if (depEntry.workspaces.size === 0) {
-        debug("No more workspaces depend on ".concat(depName, "@").concat(depEntry.version, " as a ").concat(depEntry.type, ", deleting"));
-        this.dependencies[depName] = this.dependencies[depName].filter(function (entry) {
-          return entry !== depEntry;
-        });
-      }
+  }
+  async getWorkspaceDependencies(hash, workspacePath) {
+    let file;
+    try {
+      file = await (0, _git.showFile)(hash, workspacePath, {
+        cwd: this.cwd
+      });
+    } catch (e) {
+      debug(`Could not show file ${workspacePath}@${hash}`);
+      return null;
     }
-  }], [{
-    key: "getAkDependencies",
-    value: function getAkDependencies(depMap, type) {
-      return fromEntries(Object.entries(depMap).filter(
-      // Ignore suffixed `--next` deps in jira used for independent upgrades
-      function (_ref5) {
-        var _ref6 = (0, _slicedToArray2.default)(_ref5, 1),
-          name = _ref6[0];
-        return name.includes('@atlaskit') && !name.endsWith('--next');
-      }).map(function (_ref7) {
-        var _ref8 = (0, _slicedToArray2.default)(_ref7, 2),
-          name = _ref8[0],
-          version = _ref8[1];
-        return [DependencyStore.transformDepName(name), {
-          version: DependencyStore.transformDepVersion(version),
-          type: type
-        }];
-      }));
+    let json;
+    try {
+      json = JSON.parse(file);
+    } catch (e) {
+      console.error(`Error parsing JSON - "${file}"@${hash}`);
+      return undefined;
     }
-  }, {
-    key: "getMinimumVersion",
-    value: function getMinimumVersion(versions, depName) {
-      var depOrder = ['dependency', 'peerDependency', 'devDependency', 'optionalDependency'];
-      // Sort deps before devDeps and then take the lowest version
-      var sorted = versions.sort(function (a, b) {
-        var depSort = depOrder.indexOf(a.type) - depOrder.indexOf(b.type);
-        if (depSort !== 0) {
-          return depSort;
-        }
-        var aVersion = _semver.default.coerce(a.version);
-        var bVersion = _semver.default.coerce(b.version);
-        if (!aVersion) {
-          console.error("Invalid version ".concat(depName, "@").concat(a.version));
-          return 1;
-        } else if (!bVersion) {
-          console.error("Invalid version ".concat(depName, "@").concat(b.version));
-          return -1;
-        }
-        return _semver.default.compare(aVersion, bVersion);
-      });
-      if (sorted.length > 1) {
-        debug("Multiple versions found for ".concat(depName, ": ").concat(JSON.stringify(sorted.map(function (depInfo) {
-          return _objectSpread(_objectSpread({}, depInfo), {}, {
-            workspaces: (0, _toConsumableArray2.default)(depInfo.workspaces)
-          });
-        }))));
+    let workspaceDeps = {};
+    for (const {
+      packageJsonKey,
+      depTypeName
+    } of _constants.DEP_TYPES) {
+      const wsDeps = this.getSupportedDependencies(json[packageJsonKey] || {}, depTypeName);
+      workspaceDeps = {
+        ...workspaceDeps,
+        ...wsDeps
+      };
+    }
+    return workspaceDeps;
+  }
+  updateWorkspaces(workspacePath, workspaceDeps) {
+    debug(`Updating workspace ${workspacePath}`);
+    if (!this.workspaces[workspacePath]) {
+      this.workspaces[workspacePath] = {};
+    }
+    const prevWorkspaceDeps = this.workspaces[workspacePath];
+    for (const depName of Object.keys(prevWorkspaceDeps)) {
+      if (!workspaceDeps[depName]) {
+        this.removeDependency(workspacePath, depName, prevWorkspaceDeps[depName]);
       }
-      return sorted[0];
     }
-  }, {
-    key: "transformDepName",
-    value: function transformDepName(name) {
-      // Treat `--current` as the standard dependency
-      return name.replace(/--current$/, '');
+    for (const [depName, {
+      version,
+      type
+    }] of Object.entries(workspaceDeps)) {
+      this.addDependency(workspacePath, depName, version, type);
     }
-
-    /* Coerce non-standard versions to a semver version.
-     * This essentially ignores everything up until the first number and then tries to parse a version
-     * out of that.
-     * Used to yarn alias versions used by jira's independent upgrades, e.g. npm:@atlaskit/button@^15.0.8
-     */
-  }, {
-    key: "transformDepVersion",
-    value: function transformDepVersion(version) {
-      var parts = version.split('@');
-      return parts[parts.length - 1];
+  }
+  addDependency(workspacePath, depName, version, type) {
+    if (!this.dependencies[depName]) {
+      debug(`Adding new dep ${depName}`);
+      this.dependencies[depName] = [];
+    }
+    const prevEntry = this.workspaces[workspacePath][depName];
+    const existingEntry = this.dependencies[depName].find(entry => entry.version === version && entry.type === type);
+    if (existingEntry && existingEntry === prevEntry) {
+      // We haven't added or updated the dep, exit early
+      return;
+    }
+    if (prevEntry) {
+      this.removeDependency(workspacePath, depName, prevEntry);
+    }
+    if (existingEntry) {
+      existingEntry.workspaces.add(workspacePath);
+      this.workspaces[workspacePath][depName] = existingEntry;
+    } else {
+      debug(`Adding new dependency version ${depName}@${version} (${type})`);
+      const newEntry = {
+        version,
+        type,
+        workspaces: new Set([workspacePath])
+      };
+      this.dependencies[depName].push(newEntry);
+      this.workspaces[workspacePath][depName] = newEntry;
     }
-  }]);
-  return DependencyStore;
-}(); // Object.fromEntries polyfill, remove when upgraded to node 10
+  }
+  removeDependency(workspacePath, depName, depEntry) {
+    debug(`${depName} removed from ${workspacePath}`);
+    (0, _assert.assert)(depEntry && depEntry.workspaces, `Dep entry should exist for ${depName}`);
+    depEntry.workspaces.delete(workspacePath);
+    if (depEntry.workspaces.size === 0) {
+      debug(`No more workspaces depend on ${depName}@${depEntry.version} as a ${depEntry.type}, deleting`);
+      this.dependencies[depName] = this.dependencies[depName].filter(entry => entry !== depEntry);
+    }
+  }
+  getSupportedDependencies(depMap, type) {
+    return fromEntries(Object.entries(depMap).filter(
+    // Ignore suffixed `--next` deps in jira used for independent upgrades
+    ([name]) => (0, _allowedScopes.isPackageFromSupportedScopes)(name, this.supportedScopes) && !name.endsWith('--next')).map(([name, version]) => [DependencyStore.transformDepName(name), {
+      version: DependencyStore.transformDepVersion(version),
+      type
+    }]));
+  }
+  static getMinimumVersion(versions, depName) {
+    const depOrder = ['dependency', 'peerDependency', 'devDependency', 'optionalDependency'];
+    // Sort deps before devDeps and then take the lowest version
+    const sorted = versions.sort((a, b) => {
+      const depSort = depOrder.indexOf(a.type) - depOrder.indexOf(b.type);
+      if (depSort !== 0) {
+        return depSort;
+      }
+      const aVersion = _semver.default.coerce(a.version);
+      const bVersion = _semver.default.coerce(b.version);
+      if (!aVersion) {
+        console.error(`Invalid version ${depName}@${a.version}`);
+        return 1;
+      } else if (!bVersion) {
+        console.error(`Invalid version ${depName}@${b.version}`);
+        return -1;
+      }
+      return _semver.default.compare(aVersion, bVersion);
+    });
+    if (sorted.length > 1) {
+      debug(`Multiple versions found for ${depName}: ${JSON.stringify(sorted.map(depInfo => ({
+        ...depInfo,
+        workspaces: [...depInfo.workspaces]
+      })))}`);
+    }
+    return sorted[0];
+  }
+  static transformDepName(name) {
+    // Treat `--current` as the standard dependency
+    return name.replace(/--current$/, '');
+  }
+
+  /* Coerce non-standard versions to a semver version.
+   * This essentially ignores everything up until the first number and then tries to parse a version
+   * out of that.
+   * Used to yarn alias versions used by jira's independent upgrades, e.g. npm:@atlaskit/button@^15.0.8
+   */
+  static transformDepVersion(version) {
+    const parts = version.split('@');
+    return parts[parts.length - 1];
+  }
+}
+
+// Object.fromEntries polyfill, remove when upgraded to node 10
 exports.DependencyStore = DependencyStore;
 function fromEntries(iterable) {
-  return (0, _toConsumableArray2.default)(iterable).reduce(function (obj, _ref9) {
-    var key = _ref9[0],
-      val = _ref9[1];
-    return Object.assign(obj, (0, _defineProperty2.default)({}, key, val));
-  }, {});
+  return [...iterable].reduce((obj, {
+    0: key,
+    1: val
+  }) => Object.assign(obj, {
+    [key]: val
+  }), {});
 }