@teambit/objects 0.0.0-00042bc99514ea12d897f81bcd0181e2b034c615

package/dist/models/model-component.js

@@ -0,0 +1,1509 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.VERSION_ZERO = void 0;
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _asyncMutex() {
+  const data = require("async-mutex");
+  _asyncMutex = function () {
+    return data;
+  };
+  return data;
+}
+function semver() {
+  const data = _interopRequireWildcard(require("semver"));
+  semver = function () {
+    return data;
+  };
+  return data;
+}
+function _componentVersion() {
+  const data = require("@teambit/component-version");
+  _componentVersion = function () {
+    return data;
+  };
+  return data;
+}
+function _bitError() {
+  const data = require("@teambit/bit-error");
+  _bitError = function () {
+    return data;
+  };
+  return data;
+}
+function _laneId() {
+  const data = require("@teambit/lane-id");
+  _laneId = function () {
+    return data;
+  };
+  return data;
+}
+function _componentId() {
+  const data = require("@teambit/component-id");
+  _componentId = function () {
+    return data;
+  };
+  return data;
+}
+function _pMapSeries() {
+  const data = _interopRequireDefault(require("p-map-series"));
+  _pMapSeries = function () {
+    return data;
+  };
+  return data;
+}
+function _toolboxPromise() {
+  const data = require("@teambit/toolbox.promise.map-pool");
+  _toolboxPromise = function () {
+    return data;
+  };
+  return data;
+}
+function _harmonyModules() {
+  const data = require("@teambit/harmony.modules.concurrency");
+  _harmonyModules = function () {
+    return data;
+  };
+  return data;
+}
+function _toolboxArray() {
+  const data = require("@teambit/toolbox.array.duplications-finder");
+  _toolboxArray = function () {
+    return data;
+  };
+  return data;
+}
+function _legacyBitId() {
+  const data = require("@teambit/legacy-bit-id");
+  _legacyBitId = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy() {
+  const data = require("@teambit/legacy.constants");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy2() {
+  const data = require("@teambit/legacy.consumer-component");
+  _legacy2 = function () {
+    return data;
+  };
+  return data;
+}
+function _component() {
+  const data = require("@teambit/component.sources");
+  _component = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy3() {
+  const data = require("@teambit/legacy.consumer-config");
+  _legacy3 = function () {
+    return data;
+  };
+  return data;
+}
+function _legacyCli() {
+  const data = require("@teambit/legacy.cli.error");
+  _legacyCli = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy4() {
+  const data = require("@teambit/legacy.logger");
+  _legacy4 = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy5() {
+  const data = require("@teambit/legacy.utils");
+  _legacy5 = function () {
+    return data;
+  };
+  return data;
+}
+function _pkgModules() {
+  const data = require("@teambit/pkg.modules.semver-helper");
+  _pkgModules = function () {
+    return data;
+  };
+  return data;
+}
+function _component2() {
+  const data = require("@teambit/component.snap-distance");
+  _component2 = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy6() {
+  const data = require("@teambit/legacy.scope");
+  _legacy6 = function () {
+    return data;
+  };
+  return data;
+}
+function _objects() {
+  const data = require("../objects");
+  _objects = function () {
+    return data;
+  };
+  return data;
+}
+function _scopeMeta() {
+  const data = _interopRequireDefault(require("./scopeMeta"));
+  _scopeMeta = function () {
+    return data;
+  };
+  return data;
+}
+function _versionHistory() {
+  const data = _interopRequireDefault(require("./version-history"));
+  _versionHistory = function () {
+    return data;
+  };
+  return data;
+}
+function _detachHeads() {
+  const data = require("./detach-heads");
+  _detachHeads = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+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) { _defineProperty(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; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+const VERSION_ZERO = exports.VERSION_ZERO = '0.0.0';
+
+/**
+ * we can't rename the class as ModelComponent because old components are already saved in the model
+ * with 'Component' in their headers. see object-registrar.types()
+ */
+// TODO: FIX me .parser
+class Component extends _objects().BitObject {
+  constructor(props) {
+    super();
+    _defineProperty(this, "scope", void 0);
+    _defineProperty(this, "name", void 0);
+    _defineProperty(this, "versions", void 0);
+    _defineProperty(this, "orphanedVersions", void 0);
+    _defineProperty(this, "lang", void 0);
+    /**
+     * @deprecated moved to the Version object inside teambit/deprecation aspect
+     */
+    _defineProperty(this, "deprecated", void 0);
+    _defineProperty(this, "bindingPrefix", void 0);
+    /**
+     * @deprecated since 0.12.6 (long long ago :) probably can be removed)
+     */
+    _defineProperty(this, "local", void 0);
+    _defineProperty(this, "state", void 0);
+    _defineProperty(this, "scopesList", void 0);
+    _defineProperty(this, "head", void 0);
+    _defineProperty(this, "remoteHead", void 0);
+    // doesn't get saved in the scope, used to easier access the remote main head
+    /**
+     * doesn't get saved in the scope, used to easier access the local snap head data
+     * when checked out to a lane, this prop is either Ref or null. otherwise (when on main), this prop is undefined.
+     */
+    _defineProperty(this, "laneHeadLocal", void 0);
+    /**
+     * doesn't get saved in the scope, used to easier access the remote snap head data
+     * when checked out to a lane, this prop is either Ref or null. otherwise (when on main), this prop is undefined.
+     */
+    _defineProperty(this, "laneHeadRemote", void 0);
+    /**
+     * when checked out to a lane, calculate what should be the head on the remote.
+     * if the laneHeadRemote is null, for example, when the lane is new, then used the the lane it was forked from.
+     * it no head is found on the lane/forked, then use the component.head.
+     */
+    _defineProperty(this, "calculatedRemoteHeadWhenOnLane", void 0);
+    _defineProperty(this, "laneId", void 0);
+    // doesn't get saved in the scope.
+    _defineProperty(this, "laneDataIsPopulated", false);
+    // doesn't get saved in the scope, used to improve performance of loading the lane data
+    _defineProperty(this, "schema", void 0);
+    _defineProperty(this, "detachedHeads", void 0);
+    _defineProperty(this, "divergeData", void 0);
+    _defineProperty(this, "_populateVersionHistoryMutex", void 0);
+    if (!props.name) throw new TypeError('Model Component constructor expects to get a name parameter');
+    if (!props.scope) {
+      throw new (_legacy6().BitIdCompIdError)(props.name);
+    }
+    this.scope = props.scope;
+    this.name = props.name;
+    this.versions = props.versions || {};
+    this.orphanedVersions = props.orphanedVersions || {};
+    this.lang = props.lang || _legacy().DEFAULT_LANGUAGE;
+    this.deprecated = props.deprecated || false;
+    this.bindingPrefix = props.bindingPrefix || (0, _legacy3().getBindingPrefixByDefaultScope)(props.scope);
+    this.state = props.state || {};
+    this.scopesList = props.scopesList || [];
+    this.head = props.head;
+    this.schema = props.schema;
+    this.detachedHeads = props.detachedHeads || new (_detachHeads().DetachedHeads)();
+  }
+  get populateVersionHistoryMutex() {
+    if (!this._populateVersionHistoryMutex) {
+      this._populateVersionHistoryMutex = new (_asyncMutex().Mutex)();
+    }
+    return this._populateVersionHistoryMutex;
+  }
+  get versionArray() {
+    return Object.values(this.versions);
+  }
+  setVersion(tag, ref) {
+    this.versions[tag] = ref;
+    delete this.orphanedVersions[tag]; // just in case it's there.
+  }
+  setOrphanedVersion(tag, ref) {
+    if (this.versions[tag]) {
+      throw new Error(`unable to save orphanedVersion "${tag}" for "${this.id()}" because this tag is already part of the versions prop`);
+    }
+    this.orphanedVersions[tag] = ref;
+  }
+  getRef(version) {
+    if ((0, _componentVersion().isTag)(version)) {
+      return this.versionsIncludeOrphaned[version];
+    }
+    if ((0, _componentVersion().isHash)(version)) {
+      return new (_objects().Ref)(version);
+    }
+    return null;
+  }
+  getHeadStr() {
+    return this.head ? this.head.toString() : null;
+  }
+  getHead() {
+    return this.head;
+  }
+
+  /**
+   * returns the head hash. regardless of whether current lane is the default or not.
+   * if on a lane, it returns the head of the component on the lane.
+   */
+  getHeadRegardlessOfLane() {
+    return this.laneHeadLocal || this.getHead();
+  }
+  getHeadAsTagIfExist() {
+    if (!this.head) return undefined;
+    return this.getTagOfRefIfExists(this.head) || this.head.toString();
+  }
+  hasHead() {
+    return Boolean(this.head);
+  }
+  setHead(head) {
+    this.head = head;
+  }
+  listVersions(sort) {
+    const versions = Object.keys(this.versions);
+    if (!sort) return versions;
+    if (sort === 'ASC') {
+      return versions.sort(semver().compare);
+    }
+    return versions.sort(semver().compare).reverse();
+  }
+  listVersionsIncludeOrphaned(sort) {
+    const versions = Object.keys(this.versionsIncludeOrphaned);
+    if (!sort) return versions;
+    if (sort === 'ASC') {
+      return versions.sort(semver().compare);
+    }
+    return versions.sort(semver().compare).reverse();
+  }
+  async hasVersion(version, repo, includeOrphaned = true) {
+    if ((0, _componentVersion().isTag)(version)) {
+      return includeOrphaned ? this.hasTagIncludeOrphaned(version) : this.hasTag(version);
+    }
+    const head = this.getHeadRegardlessOfLane();
+    if (!head) {
+      return false;
+    }
+    const versionParents = await (0, _component2().getAllVersionParents)({
+      repo,
+      modelComponent: this,
+      heads: [head]
+    });
+    // we use "startsWith" because it can be a short hash
+    return versionParents.map(v => v.hash).some(hash => hash.toString().startsWith(version));
+  }
+  hasTag(version) {
+    return Boolean(this.versions[version]);
+  }
+  get versionsIncludeOrphaned() {
+    // for bit-bin with 266 components, it takes about 1,700ms. don't use lodash.merge, it's much faster
+    // but mutates `this.versions`.
+    return _objectSpread(_objectSpread({}, this.versions), this.orphanedVersions);
+  }
+  hasTagIncludeOrphaned(version) {
+    return Boolean(this.versions[version] || this.orphanedVersions[version]);
+  }
+
+  /**
+   * whether the head is a snap (not a tag)
+   */
+  isHeadSnap() {
+    const tagsHashes = this.versionArray.map(ref => ref.toString());
+    return this.head && !tagsHashes.includes(this.head.toString());
+  }
+
+  /**
+   * add a new remote if it is not there already
+   */
+  addScopeListItem(scopeListItem) {
+    if (!scopeListItem.name || !scopeListItem.url || !scopeListItem.date) {
+      throw new TypeError(`model-component.addRemote get an invalid remote. name: ${scopeListItem.name}, url: ${scopeListItem.url}, date: ${scopeListItem.date}`);
+    }
+    if (!this.scopesList.find(r => r.url === scopeListItem.url)) {
+      this.scopesList.push(scopeListItem);
+    }
+  }
+
+  /**
+   * on main - it checks local-head (or .bitmap version if given) vs remote-head.
+   * on lane - it checks local-head on lane vs remote-head on lane.
+   * however, to get an accurate `divergeData.snapsOnSourceOnly`, the above is not enough.
+   * for example, comp-a@snap-x from lane-a is merged into lane-b. we don't want this snap-x to be "local", because
+   * then, bit-status will show it as "staged" and bit-reset will remove it unexpectedly.
+   * if we only check by the local-head and remote-head on lane, it'll be local because the remote-head of lane-b is empty.
+   * to address this, we search all remote-refs files for this bit-id and during the local history traversal, if a hash
+   * is found there, it'll stop the traversal and not mark it as remote.
+   * in this example, during the merge, lane-a was fetched, and the remote-ref of this lane has snap-x as the head.
+   */
+  async setDivergeData(repo, throws = true, fromCache = true, workspaceId) {
+    if (!this.divergeData || !fromCache) {
+      const remoteHead = (this.laneId ? this.calculatedRemoteHeadWhenOnLane : this.remoteHead) || null;
+      // this is for detach-head scenario. it can happen on main only. we want to compare against the .bitmap
+      // version (which is the detached head) and not the actual head.
+      const workspaceVersion = !this.isOnLane() && workspaceId?.hasVersion() ? workspaceId.version : null;
+      this.divergeData = await (0, _component2().getDivergeData)({
+        repo,
+        modelComponent: this,
+        targetHead: remoteHead,
+        sourceHead: workspaceVersion ? this.getRef(workspaceVersion) : undefined,
+        throws
+      });
+    }
+  }
+  isOnLane() {
+    return Boolean(this.laneHeadLocal || this.laneHeadLocal === null);
+  }
+
+  /**
+   * this is used (among others) by `bit status` to check whether snaps are local (staged), for `bit reset` to remove them
+   * and for `bit export` to push them. for "merge pending" status, use `this.getDivergeDataForMergePending()`.
+   */
+  getDivergeData() {
+    if (!this.divergeData) throw new Error(`getDivergeData() expects divergeData to be populate, please use this.setDivergeData() for id: ${this.id()}`);
+    return this.divergeData;
+  }
+
+  /**
+   * don't use modelComponent.getDivergeData() because in some scenarios when on a lane, it compares the head
+   * on the lane against the head on the main, which could show the component as diverged incorrectly.
+   */
+  async getDivergeDataForMergePending(repo) {
+    return (0, _component2().getDivergeData)({
+      repo,
+      modelComponent: this,
+      targetHead: (this.laneId ? this.laneHeadRemote : this.remoteHead) || null,
+      throws: false
+    });
+  }
+  async populateLocalAndRemoteHeads(repo, lane) {
+    this.setLaneHeadLocal(lane);
+    if (lane) this.laneId = lane.toLaneId();
+    if (!this.scope) {
+      return; // no remote to update. it's local.
+    }
+    this.remoteHead = await repo.remoteLanes.getRef(_laneId().LaneId.from(_laneId().DEFAULT_LANE, this.scope), this.toComponentId());
+    if (!lane) {
+      return;
+    }
+    this.laneHeadRemote = lane.isNew ? null : await repo.remoteLanes.getRef(lane.toLaneId(), this.toComponentId());
+    const calculateRemote = async () => {
+      if (this.laneHeadRemote) return this.laneHeadRemote;
+      if (lane.isNew && lane.forkedFrom) {
+        // For any forked lane — same-scope or cross-scope (e.g. after `bit lane change-scope`) — use
+        // the forked-from lane's head as the divergence baseline. The consumer has that ref locally
+        // from when they ran `bit lane import` on the original lane. This is correct for both:
+        //  - same-scope forks: identical to the previous behavior.
+        //  - cross-scope forks: previously fell through to `this.remoteHead || this.head`, which can
+        //    crash with `TargetHeadNotFound` when the component's main-head Version isn't local
+        //    (common after a lean-lane import since main history doesn't live on the lane scope).
+        //    Returning the fork's head instead reports only true local snaps as staged — not the
+        //    entire history — which also keeps `bit reset` from over-removing.
+        const headFromFork = await repo.remoteLanes.getRef(lane.forkedFrom, this.toComponentId());
+        if (headFromFork) return headFromFork;
+        if (lane.forkedFrom.scope !== lane.scope) {
+          // Cross-scope fork and the forked-from ref isn't local. Returning null over-reports
+          // the lane history as staged (divergence has no baseline), but falling through to
+          // `this.remoteHead || this.head` would crash with TargetHeadNotFound when the main-
+          // head Version is missing locally. The user can recover by running `bit lane fetch`
+          // on the forked-from lane to populate the ref.
+          return null;
+        }
+        // Same-scope fork without a fork ref — fall through to the standard fallback below.
+      }
+      // if no remote-ref was found, because it's checked out to a lane, it's safe to assume that
+      // this.head should be on the original-remote. hence, FetchMissingHistory will retrieve it on lane-remote
+      return this.remoteHead || this.head;
+    };
+    this.calculatedRemoteHeadWhenOnLane = await calculateRemote();
+  }
+  setLaneHeadLocal(lane) {
+    if (lane) {
+      // include lane.updateDependents — hidden cascade entries need a lane-local head so the
+      // export-pending detector picks them up after a workspace cascade snap.
+      this.laneHeadLocal = lane.getCompHeadIncludeUpdateDependents(this.toComponentId()) || null;
+    }
+  }
+
+  /**
+   * returns only the versions that exist in both components (regardless whether the hash are the same)
+   * e.g. this.component = [0.0.1, 0.0.2, 0.0.3], other component = [0.0.3, 0.0.4]. it returns only [0.0.3].
+   * also, in case it is coming from 'bit import', the version must be locally changed.
+   * otherwise, it doesn't matter whether the hashes are different.
+   */
+  _getComparableVersionsObjects(otherComponent,
+  // in case of merging, the otherComponent is the existing component, and "this" is the incoming component
+  local) {
+    const otherLocalVersion = otherComponent.getLocalVersions();
+    const otherComponentVersions = (0, _lodash().pickBy)(otherComponent.versions, (val, key) => Object.keys(this.versions).includes(key) && (!local || otherLocalVersion.includes(key)));
+    const thisComponentVersions = (0, _lodash().pickBy)(this.versions, (val, key) => Object.keys(otherComponentVersions).includes(key) && (!local || otherLocalVersion.includes(key)));
+    return {
+      thisComponentVersions,
+      otherComponentVersions
+    };
+  }
+  compatibleWith(component, local) {
+    const {
+      thisComponentVersions,
+      otherComponentVersions
+    } = this._getComparableVersionsObjects(component, local);
+    return (0, _lodash().isEqual)(thisComponentVersions, otherComponentVersions);
+  }
+  diffWith(component, local) {
+    const {
+      thisComponentVersions,
+      otherComponentVersions
+    } = this._getComparableVersionsObjects(component, local);
+    return Object.keys(thisComponentVersions).filter(version => thisComponentVersions[version].hash !== otherComponentVersions[version].hash);
+  }
+  isEmpty() {
+    return (0, _lodash().isEmpty)(this.versions) && !this.hasHead();
+  }
+
+  /**
+   * on main return main head, on lane, return lane head.
+   * if the head is also a tag, return the tag, otherwise, return the hash.
+   */
+  getHeadRegardlessOfLaneAsTagOrHash(returnVersionZeroForNoHead = false) {
+    const head = this.getHeadRegardlessOfLane();
+    if (!head) {
+      if (!(0, _lodash().isEmpty)(this.versions)) throw new Error(`error: ${this.id()} has tags but no head, it might be originated from legacy`);
+      if (returnVersionZeroForNoHead) return VERSION_ZERO;
+      throw new Error(`getHeadRegardlessOfLaneAsTagOrHash() failed finding a head for ${this.id()}`);
+    }
+    return this.getTagOfRefIfExists(head) || head.toString();
+  }
+
+  /**
+   * get the recent head. if locally is ahead, return the local head. otherwise, return the remote head.
+   *
+   * a user can be checked out to a lane, in which case, `this.laneHeadLocal` and `this.laneHeadRemote`
+   * may be populated.
+   * `this.head` may not be populated, e.g. when a component was created on
+   * this lane and never got snapped on main.
+   * it's impossible that `this.head.isEqual(this.laneHeadLocal)`, because when snapping it's either
+   * on main, which goes to this.head OR on a lane, which goes to this.laneHeadLocal.
+   */
+  async headIncludeRemote(repo) {
+    const latestLocally = this.getHeadRegardlessOfLaneAsTagOrHash(true);
+    const remoteHead = this.laneHeadRemote || this.remoteHead;
+    if (!remoteHead) return latestLocally;
+    if (!this.getHeadRegardlessOfLane()) {
+      return remoteHead.toString(); // in case a snap was created on another lane
+    }
+
+    // either a user is on main or a lane, check whether the remote is ahead of the local
+    if (this.laneId && !this.laneHeadRemote) {
+      // when on a lane, setDivergeData is using the `this.calculatedRemoteHeadWhenOnLane`,
+      // which takes into account main-head and forked-head. here, we don't want this. we care only about the
+      // remote-lane head.
+      return latestLocally;
+    }
+    await this.setDivergeData(repo, false);
+    const divergeData = this.getDivergeData();
+    if (divergeData.isTargetAhead()) {
+      return this.getTagOfRefIfExists(remoteHead) || remoteHead.toString();
+    }
+    return latestLocally;
+  }
+  async getRefOfAncestor(repo, generationsToGoBack) {
+    const head = this.getHeadRegardlessOfLane();
+    if (!head) throw new (_bitError().BitError)(`getRefOfAncestor failed to find the head of ${this.id()}`);
+    const versionHistory = await this.getAndPopulateVersionHistory(repo, head);
+    return versionHistory.getAncestor(generationsToGoBack, head);
+  }
+  latestVersion() {
+    if ((0, _lodash().isEmpty)(this.versions)) return VERSION_ZERO;
+    return (0, _pkgModules().getLatestVersion)(this.listVersions());
+  }
+  latestVersionIfExist() {
+    if ((0, _lodash().isEmpty)(this.versions)) return undefined;
+    return (0, _pkgModules().getLatestVersion)(this.listVersions());
+  }
+
+  // @todo: make it readable, it's a mess
+  isLatestGreaterThan(version) {
+    if (!version) throw TypeError('isLatestGreaterThan expect to get a Version');
+    const latest = this.getHeadRegardlessOfLaneAsTagOrHash(true);
+    if (this.isEmpty() && !this.calculatedRemoteHeadWhenOnLane) {
+      return false; // in case a snap was created on another lane
+    }
+    if ((0, _componentVersion().isTag)(latest) && (0, _componentVersion().isTag)(version)) {
+      return semver().gt(latest, version);
+    }
+    if (latest === version) return false;
+    const latestRef = this.getRef(latest);
+    if (!latestRef) throw new Error('isLatestGreaterThan, latestRef was not found');
+    const latestHash = latestRef.toString();
+    const versionRef = this.getRef(version);
+    if (!versionRef) return true; // probably a child
+    const versionHash = versionRef.toString();
+    if (latestHash === versionHash) return false;
+    return true;
+  }
+
+  /**
+   * Return the lateset version which actuall exists in the scope
+   * (exists means the object itself exists)
+   * This relevant for cases when the component version array has few versions
+   * but we don't have all the refs in the object
+   *
+   * @returns {number}
+   * @memberof Component
+   */
+  latestExisting(repository) {
+    if ((0, _lodash().isEmpty)(this.versions)) return VERSION_ZERO;
+    const versions = this.listVersions('ASC');
+    let version = null;
+    let versionStr = null;
+    while (!version && versions && versions.length) {
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      versionStr = versions.pop();
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      version = this.loadVersionSync(versionStr, repository, false);
+    }
+    return versionStr || VERSION_ZERO;
+  }
+
+  /**
+   * get component log and sort by the timestamp in ascending order (from the earliest to the latest)
+   */
+  async collectLogs(scope, shortHash = false, startFrom) {
+    const repo = scope.objects;
+    let versionsInfo = await (0, _component2().getAllVersionsInfo)({
+      modelComponent: this,
+      repo,
+      throws: false,
+      startFrom
+    });
+
+    // due to recent changes of getting version-history object rather than fetching the entire history, some version
+    // objects might be missing. import the component from the remote
+    if (versionsInfo.some(v => v.error && (0, _legacy6().errorIsTypeOfMissingObject)(v.error)) && this.scope !== repo.scopeJson.name) {
+      _legacy4().logger.info(`collectLogs is unable to find some objects for ${this.id()}. will try to import them`);
+      try {
+        const lane = await scope.getCurrentLaneObject();
+        await scope.scopeImporter.importWithoutDeps(_componentId().ComponentIdList.fromArray([this.toComponentId()]).toVersionLatest(), {
+          cache: false,
+          includeVersionHistory: true,
+          collectParents: true,
+          lane: lane || undefined,
+          reason: 'to collect logs (including parents)'
+        });
+        versionsInfo = await (0, _component2().getAllVersionsInfo)({
+          modelComponent: this,
+          repo,
+          throws: false,
+          startFrom
+        });
+        // Lean-lane-scope fallback: if the lane is on a different scope from the component's
+        // home scope (e.g. a feature lane for a component that lives on main in another scope),
+        // older main snaps may not be on the lane scope. Re-fetch without lane so the fetcher
+        // routes to the component's home scope and brings in the missing main history.
+        if (lane && lane.scope !== this.scope && versionsInfo.some(v => v.error && (0, _legacy6().errorIsTypeOfMissingObject)(v.error))) {
+          await scope.scopeImporter.importWithoutDeps(_componentId().ComponentIdList.fromArray([this.toComponentId()]).toVersionLatest(), {
+            cache: false,
+            includeVersionHistory: true,
+            collectParents: true,
+            reason: 'to collect logs from component home scope (lean-lane-scope fallback)'
+          });
+          versionsInfo = await (0, _component2().getAllVersionsInfo)({
+            modelComponent: this,
+            repo,
+            throws: false,
+            startFrom
+          });
+        }
+      } catch (err) {
+        _legacy4().logger.error(`collectLogs failed to import ${this.id()} history`, err);
+      }
+    }
+    const head = this.getHeadRegardlessOfLane();
+    const headVersion = head ? await repo.load(head) : undefined;
+    const removeAspect = headVersion?.extensions.findCoreExtension(_legacy().Extensions.remove);
+    const removeRange = removeAspect?.config.range;
+    const removeSnaps = removeAspect?.config.snaps || [];
+    const deprecationAspect = headVersion?.extensions.findCoreExtension(_legacy().Extensions.deprecation);
+    const deprecationRange = deprecationAspect?.config.range;
+    const getRef = ref => shortHash ? ref.toShortString() : ref.toString();
+    const results = versionsInfo.map(versionInfo => {
+      const log = versionInfo.version ? versionInfo.version.log : {
+        message: '<no-data-available>'
+      };
+      return _objectSpread(_objectSpread({}, log), {}, {
+        // @ts-ignore
+        username: log?.username || 'unknown',
+        // @ts-ignore
+        email: log?.email || 'unknown',
+        tag: versionInfo.tag,
+        hash: getRef(versionInfo.ref),
+        parents: versionInfo.parents.map(parent => getRef(parent)),
+        onLane: versionInfo.onLane,
+        deleted: versionInfo.tag && removeRange && semver().satisfies(versionInfo.tag, removeRange) || !versionInfo.tag && removeSnaps.includes(versionInfo.ref.toString()),
+        deprecated: versionInfo.tag && deprecationRange && semver().satisfies(versionInfo.tag, deprecationRange),
+        hidden: versionInfo.version?.hidden
+      });
+    });
+    // sort from earliest to latest
+    const sorted = results.sort((a, b) => {
+      // @ts-ignore
+      if (a.date && b.date) return a.date - b.date;
+      return 0;
+    });
+    return sorted;
+  }
+  collectVersions(repo) {
+    return Promise.all(this.listVersions().map(versionNum => {
+      return this.toConsumerComponent(versionNum, this.scope, repo);
+    }));
+  }
+  getTagOfRefIfExists(ref, allTags = this.versionsIncludeOrphaned) {
+    return Object.keys(allTags).find(versionRef => allTags[versionRef].isEqual(ref));
+  }
+  getTag(version) {
+    if ((0, _componentVersion().isTag)(version)) return version;
+    const ref = _objects().Ref.from(version);
+    return this.getTagOfRefIfExists(ref);
+  }
+  switchHashesWithTagsIfExist(refs) {
+    // cache the this.versionsIncludeOrphaned results into "allTags", looks strange but it improved
+    // the performance on bit-bin with 188 components during source.merge in 4 seconds.
+    const allTags = this.versionsIncludeOrphaned;
+    return refs.map(ref => this.getTagOfRefIfExists(ref, allTags) || ref.toString());
+  }
+
+  /**
+   * if exactVersion is defined, add exact version instead of using the semver mechanism
+   */
+  getVersionToAdd(releaseType = _legacy().DEFAULT_BIT_RELEASE_TYPE, exactVersion, incrementBy, preReleaseId) {
+    if (exactVersion && this.versions[exactVersion]) {
+      throw new (_legacy6().VersionAlreadyExists)(exactVersion, this.id());
+    }
+    const version = exactVersion || this.version(releaseType, incrementBy, preReleaseId);
+    (0, _pkgModules().validateVersion)(version);
+    return version;
+  }
+  isEqual(component, considerOrphanedVersions = true) {
+    if (this.hasHead() && !component.hasHead() || !this.hasHead() && component.hasHead()) {
+      return false; // only one of them has head
+    }
+    if (this.head && component.head && !this.head.isEqual(component.head)) {
+      return false; // the head is not equal.
+    }
+    // the head is equal or they both don't have head. check the versions
+    if (this.versionArray.length !== component.versionArray.length) {
+      return false;
+    }
+    const hasSameVersions = Object.keys(this.versions).every(tag => component.versions[tag] && component.versions[tag].isEqual(this.versions[tag]));
+    if (considerOrphanedVersions) {
+      if (Object.keys(this.orphanedVersions).length !== Object.keys(component.orphanedVersions).length) {
+        return false;
+      }
+      const hasSameOrphanedVersions = Object.keys(this.orphanedVersions).every(tag => component.orphanedVersions[tag] && component.orphanedVersions[tag].isEqual(this.orphanedVersions[tag]));
+      if (!hasSameOrphanedVersions) {
+        return false;
+      }
+    }
+    return hasSameVersions;
+  }
+
+  // eslint-disable-next-line complexity
+  addVersion(version, versionToAdd, lane, previouslyUsedVersion, {
+    addToUpdateDependentsInLane,
+    setHeadAsParent,
+    detachHead,
+    overrideHead
+  } = {}) {
+    if (detachHead && overrideHead) {
+      throw new Error(`addVersion expects either detachHead or overrideHead to be true, not both`);
+    }
+    if (lane) {
+      if ((0, _componentVersion().isTag)(versionToAdd)) {
+        throw new (_bitError().BitError)('unable to tag when checked out to a lane, please switch to main, merge the lane and then tag again');
+      }
+      const currentBitId = this.toComponentId();
+      const versionToAddRef = _objects().Ref.from(versionToAdd);
+      const parent = previouslyUsedVersion ? this.getRef(previouslyUsedVersion) : null;
+      if (!parent) {
+        const existingComponentInLane = lane.getComponent(currentBitId);
+        const currentHead = existingComponentInLane && existingComponentInLane.head || this.getHead();
+        if (currentHead) {
+          throw new Error(`component ${currentBitId.toString()} has a head (${currentHead.toString()}) but previouslyUsedVersion is empty`);
+        }
+      }
+      if (parent && !parent.isEqual(versionToAddRef)) {
+        version.addAsOnlyParent(parent);
+      }
+      // When the caller didn't explicitly opt in or out, preserve the existing entry's bucket so
+      // a merge-from-main producing a new snap for a hidden updateDependent keeps it hidden
+      // rather than promoting it into workspace-tracked state.
+      const existingHidden = lane.findUpdateDependent(currentBitId);
+      const existingVisible = lane.getComponent(currentBitId);
+      const shouldBeHidden = addToUpdateDependentsInLane ?? (Boolean(existingHidden) && !existingVisible);
+      if (shouldBeHidden) {
+        if (existingVisible) lane.removeComponent(currentBitId);
+        lane.addComponentToUpdateDependents(currentBitId.changeVersion(versionToAddRef.toString()));
+        // Only brand-new hidden insertions raise the wire flag — that's the `_snap --update-dependents`
+        // path adding a component that wasn't already on the lane. Cascades update an existing
+        // hidden entry (wasAlreadyHidden=true) and must NOT raise the flag, otherwise origin would
+        // re-add entries the Cloud UI explicitly dropped.
+        if (!existingHidden) lane.setOverrideUpdateDependents(true);
+      } else {
+        if (existingHidden) lane.removeComponentFromUpdateDependentsIfExist(currentBitId);
+        lane.addComponent({
+          id: currentBitId,
+          head: versionToAddRef,
+          isDeleted: version.isRemoved()
+        });
+      }
+      if (lane.readmeComponent && lane.readmeComponent.id.fullName === currentBitId.fullName) {
+        lane.setReadmeComponent(currentBitId);
+      }
+      this.laneHeadLocal = versionToAddRef;
+      return versionToAdd;
+    }
+    // user on main
+    const head = this.getHead();
+    const parent = previouslyUsedVersion ? this.getRef(previouslyUsedVersion) : null;
+    if (head && head.toString() !== versionToAdd && !this.hasTag(versionToAdd) // happens with auto-snap
+    ) {
+      // if this is a tag and this tag exists, the same version was added before with a different hash.
+      // adding the current head into the parent will result in a non-exist hash in the parent.
+      // if this is a hash and it's the same hash as the current head, adding it as a parent
+      // results in a parent and a version has the same hash.
+      // @todo: fix it in a more elegant way
+      const parentToSet = setHeadAsParent ? head : parent;
+      version.addAsOnlyParent(parentToSet || head);
+    }
+    if (parent && head && !parent.isEqual(head) && !overrideHead) {
+      if (detachHead) this.detachedHeads.setHead(version.hash());else throw new Error(`unable to add a new version for "${this.id()}" on main.
+this version started from an older version (${previouslyUsedVersion}), and not from the head (${head}).
+please run "bit checkout head" to be up to date, then snap/tag your changes.
+if this is done intentionally, you can use --detach-head (or --override-head if available), but make sure you understand the implications as this is an experimental feature that may not be fully stable.`);
+    } else {
+      this.setHead(version.hash());
+      this.detachedHeads.clearCurrent();
+    }
+    if ((0, _componentVersion().isTag)(versionToAdd)) {
+      this.setVersion(versionToAdd, version.hash());
+    }
+    this.markVersionAsLocal(versionToAdd);
+    return versionToAdd;
+  }
+  version(releaseType = _legacy().DEFAULT_BIT_RELEASE_TYPE, incrementBy = 1, preReleaseId) {
+    const increment = ver => {
+      try {
+        // don't use "semver.inc" function, it'll swallow the error and return null.
+        const incResult = new (semver().SemVer)(ver).inc(releaseType, preReleaseId);
+        return incResult.version;
+      } catch (err) {
+        throw new Error(`unable to increment version "${ver}" with releaseType "${releaseType}" and preReleaseId "${preReleaseId}".
+Error from "semver": ${err.message}`);
+      }
+    };
+    const latest = this.latestVersion();
+    if (!latest) {
+      const isPreReleaseLike = ['prerelease', 'premajor', 'preminor', 'prepatch'].includes(releaseType);
+      return isPreReleaseLike ? increment(_legacy().DEFAULT_BIT_VERSION) : _legacy().DEFAULT_BIT_VERSION;
+    }
+    let result = increment(latest);
+    if (incrementBy === 1) return result;
+    for (let i = 1; i < incrementBy; i += 1) {
+      result = increment(result);
+    }
+    return result;
+  }
+  id() {
+    return this.scope ? [this.scope, this.name].join('/') : this.name;
+  }
+
+  /**
+   * @deprecated use toComponentId() instead
+   */
+  toBitId() {
+    return new (_legacyBitId().BitId)({
+      scope: this.scope,
+      name: this.name
+    });
+  }
+  toComponentId() {
+    if (!this.scope) throw new Error(`ModelComponent: scope is missing from "${this.name}"`);
+    return new (_componentId().ComponentID)(this.toBitId());
+  }
+
+  /**
+   * @deprecated use toComponentIdWithLatestVersion() instead
+   */
+  toBitIdWithLatestVersion() {
+    return new (_legacyBitId().BitId)({
+      scope: this.scope,
+      name: this.name,
+      version: this.getHeadRegardlessOfLaneAsTagOrHash(true)
+    });
+  }
+  toComponentIdWithLatestVersion() {
+    return _componentId().ComponentID.fromObject({
+      scope: this.scope,
+      name: this.name,
+      version: this.getHeadRegardlessOfLaneAsTagOrHash(true)
+    });
+  }
+  toComponentIdWithHead() {
+    return _componentId().ComponentID.fromObject({
+      scope: this.scope,
+      name: this.name,
+      version: this.head?.toString()
+    });
+  }
+  toBitIdWithLatestVersionAllowNull() {
+    const id = this.toComponentIdWithLatestVersion();
+    return id.version === VERSION_ZERO ? id.changeVersion(undefined) : id;
+  }
+  toObject() {
+    function versions(vers) {
+      const obj = {};
+      (0, _lodash().forEach)(vers, (ref, version) => {
+        obj[version] = ref.toString();
+      });
+      return obj;
+    }
+    const componentObject = {
+      name: this.name,
+      scope: this.scope,
+      versions: versions(this.versions),
+      lang: this.lang,
+      deprecated: this.deprecated,
+      bindingPrefix: this.bindingPrefix,
+      remotes: this.scopesList,
+      schema: this.schema,
+      detachedHeads: this.detachedHeads.toObject()
+    };
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    if (this.local) componentObject.local = this.local;
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    if (!(0, _lodash().isEmpty)(this.state)) componentObject.state = this.state;
+    // @ts-ignore
+    if (!(0, _lodash().isEmpty)(this.orphanedVersions)) componentObject.orphanedVersions = versions(this.orphanedVersions);
+    const headStr = this.getHeadStr();
+    // @ts-ignore
+    if (headStr) componentObject.head = headStr;
+    return componentObject;
+  }
+  async loadVersion(versionStr, repository, throws = true) {
+    const versionRef = this.getRef(versionStr);
+    if (!versionRef) throw new (_legacy6().VersionNotFound)(versionStr, this.id());
+    const version = await repository.load(versionRef, false);
+    if (!version && throws) throw new (_legacy6().VersionNotFoundOnFS)(versionStr, this.id());
+    return version;
+  }
+  loadVersionSync(version, repository, throws = true) {
+    const versionRef = this.getRef(version);
+    if (!versionRef) throw new (_legacy6().VersionNotFound)(version, this.id());
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    return versionRef.loadSync(repository, throws);
+  }
+  async collectVersionsObjects(repo, versions, throwForMissingLocalArtifacts = false, workspaceId) {
+    const refsWithoutArtifacts = [];
+    const artifactsRefs = [];
+    const artifactsRefsFromExportedVersions = [];
+    const locallyChangedVersions = await this.getLocalTagsOrHashes(repo, workspaceId);
+    const locallyChangedHashes = locallyChangedVersions.map(v => (0, _componentVersion().isTag)(v) ? this.versionsIncludeOrphaned[v].hash : v);
+    const versionsRefs = versions.map(version => this.getRef(version));
+    refsWithoutArtifacts.push(...versionsRefs);
+    const versionsObjects = await Promise.all(versionsRefs.map(versionRef => this.loadVersion(versionRef.toString(), repo)));
+    versionsObjects.forEach(versionObject => {
+      const refs = versionObject.refsWithOptions(false, false);
+      refsWithoutArtifacts.push(...refs);
+      const refsFromExtensions = (0, _component().getRefsFromExtensions)(versionObject.extensions);
+      locallyChangedHashes.includes(versionObject.hash().toString()) ? artifactsRefs.push(...refsFromExtensions) : artifactsRefsFromExportedVersions.push(...refsFromExtensions);
+    });
+    const loadedRefs = [];
+    try {
+      const loaded = await repo.loadManyRaw(refsWithoutArtifacts);
+      loadedRefs.push(...loaded);
+    } catch (err) {
+      if (err.code === 'ENOENT') {
+        throw new Error(`unable to find an object file "${err.path}"
+for a component "${this.id()}", versions: ${versions.join(', ')}`);
+      }
+      throw err;
+    }
+    try {
+      const loaded = throwForMissingLocalArtifacts ? await repo.loadManyRaw(artifactsRefs) : await repo.loadManyRawIgnoreMissing(artifactsRefs);
+      loadedRefs.push(...loaded);
+      // ignore missing artifacts when exporting old versions that were exported in the past and are now exported to a
+      // different scope. this is happening for example when exporting a lane that has components from different
+      // remotes. it's ok to not have all artifacts from the other remotes to this remote.
+      const loadedExportedArtifacts = await repo.loadManyRawIgnoreMissing(artifactsRefsFromExportedVersions);
+      loadedRefs.push(...loadedExportedArtifacts);
+    } catch (err) {
+      if (err.code === 'ENOENT') {
+        throw new Error(`unable to find an artifact object file "${err.path}"
+for a component "${this.id()}", versions: ${versions.join(', ')}
+consider using --ignore-missing-artifacts flag if you're sure the artifacts are in the remote`);
+      }
+      throw err;
+    }
+    return loadedRefs;
+  }
+  async collectObjects(repo) {
+    try {
+      const [rawComponent, objects] = await Promise.all([this.asRaw(repo), this.collectRaw(repo)]);
+      return new (_legacy6().ComponentObjects)(rawComponent, objects.map(o => o.buffer));
+    } catch (err) {
+      if (err.code === 'ENOENT') {
+        throw new Error(`fatal: an object of "${this.id()}" was not found at ${err.path}\nplease try to re-import the component`);
+      }
+      throw err;
+    }
+  }
+
+  /**
+   * to delete a version from a component, don't call this method directly. Instead, use sources.removeVersion()
+   */
+  removeVersion(version) {
+    const objectRef = this.getRef(version);
+    if (!objectRef) throw new Error(`removeVersion failed finding version ${version}`);
+    delete this.versions[version];
+    if (this.state.versions && this.state.versions[version]) delete this.state.versions[version];
+    return objectRef;
+  }
+  toComponentVersion(versionStr) {
+    const versionParsed = (0, _componentVersion().versionParser)(versionStr);
+    const versionNum = versionParsed.latest ? this.getHeadRegardlessOfLaneAsTagOrHash(true) : versionParsed.versionNum;
+    if (versionNum === VERSION_ZERO) {
+      throw new (_legacy6().NoHeadNoVersion)(this.id());
+    }
+    if ((0, _componentVersion().isTag)(versionNum) && !this.hasTagIncludeOrphaned(versionNum)) {
+      throw new (_bitError().BitError)(`the version ${versionNum} of "${this.id()}" does not exist in ${this.listVersionsIncludeOrphaned().join('\n')}, versions array.`);
+    }
+    return new (_legacy6().ComponentVersion)(this, versionNum);
+  }
+
+  /**
+   * if no "specificVersion" is given, it returns according to the head
+   */
+  async isDeprecated(repo, specificVersion) {
+    // backward compatibility
+    if (this.deprecated) {
+      return true;
+    }
+    const head = this.getHeadRegardlessOfLane();
+    if (!head) {
+      // it's legacy, or new. If legacy, the "deprecated" prop should do. if it's new, the workspace should
+      // have the answer.
+      return false;
+    }
+    const headVersion = await repo.load(head);
+    if (!headVersion) {
+      // the head Version doesn't exist locally, there is no way to know whether it's deprecated
+      return null;
+    }
+    const deprecationAspect = headVersion.extensions.findCoreExtension(_legacy().Extensions.deprecation);
+    if (!deprecationAspect) {
+      return false;
+    }
+    if (deprecationAspect.config.deprecate) {
+      return true;
+    }
+    if (specificVersion && deprecationAspect.config.range) {
+      const tag = this.getTag(specificVersion);
+      if (!tag) return false; // it's a snap. "range" doesn't support deprecating snaps. only semver.
+      return semver().satisfies(tag, deprecationAspect.config.range);
+    }
+    return false;
+  }
+
+  /**
+   * whether the head is marked as internal. internal components are still versioned and exported,
+   * but are hidden by default in the UI (workspace, scope and Bit Cloud).
+   */
+  async isInternal(repo) {
+    const head = this.getHeadRegardlessOfLane();
+    if (!head) {
+      // it's new. the workspace should have the answer.
+      return false;
+    }
+    const headVersion = await repo.load(head);
+    if (!headVersion) {
+      // the head Version doesn't exist locally, there is no way to know whether it's internal
+      return null;
+    }
+    const internalizeAspect = headVersion.extensions.findCoreExtension(_legacy().Extensions.internalize);
+    if (!internalizeAspect) {
+      return false;
+    }
+    return Boolean(internalizeAspect.config.internal);
+  }
+  async isRemoved(repo, specificVersion) {
+    const getHead = () => {
+      if (!this.laneHeadLocal) return this.getHead();
+      // you're checked out to a lane.
+      if (!specificVersion) return this.laneHeadLocal;
+      // it's possible that this specificVersion is from main.
+      if (specificVersion === this.laneHeadLocal.toString()) return this.laneHeadLocal;
+      return this.getHead();
+    };
+    const head = getHead();
+    if (!head) {
+      // it's new or only on lane
+      return false;
+    }
+    const headVersion = await repo.load(head);
+    if (!headVersion) {
+      // the head Version doesn't exist locally, there is no way to know whether it's removed
+      return null;
+    }
+    const removeAspect = headVersion.extensions.findCoreExtension(_legacy().Extensions.remove);
+    if (!removeAspect) {
+      return false;
+    }
+    if (removeAspect.config.removed) {
+      return true;
+    }
+    if (specificVersion) {
+      if (removeAspect.config.range) {
+        const tag = this.getTag(specificVersion);
+        if (tag) return semver().satisfies(tag, removeAspect.config.range);
+      }
+      if (removeAspect.config.snaps && Array.isArray(removeAspect.config.snaps)) {
+        return removeAspect.config.snaps.includes(specificVersion);
+      }
+    }
+    return false;
+  }
+  async isLaneReadmeOf(repo) {
+    const head = this.getHeadRegardlessOfLane();
+    if (!head) {
+      // we dont support lanes in legacy
+      return [];
+    }
+    const version = await repo.load(head);
+    if (!version) {
+      // the head Version doesn't exist locally, there is no way to know whether it is a lane readme component
+      return [];
+    }
+    const lanesAspect = version.extensions.findCoreExtension(_legacy().Extensions.lanes);
+    if (!lanesAspect || !lanesAspect.config.readme) {
+      return [];
+    }
+    return Object.keys(lanesAspect.config.readme);
+  }
+  /**
+   * convert a ModelComponent of a specific version to ConsumerComponent
+   * @see sources.consumerComponentToVersion() for the opposite action.
+   */
+  async toConsumerComponent(versionStr, scopeName, repository) {
+    _legacy4().logger.trace(`model-component, converting ${this.id()}, version: ${versionStr} to ConsumerComponent`);
+    let componentVersion = this.toComponentVersion(versionStr);
+    const version = await componentVersion.getVersion(repository);
+    // in case the the version is a short-hash, it should be converted to a full hash.
+    if (versionStr !== _componentVersion().LATEST_VERSION && !(0, _componentVersion().isTag)(versionStr) && !(0, _componentVersion().isSnap)(versionStr) && version.hash().toString() !== versionStr) {
+      componentVersion = new (_legacy6().ComponentVersion)(this, version.hash().toString());
+    }
+    const resolvedVersion = componentVersion.version;
+    const loadFileInstance = ClassName => async file => {
+      const loadP = file.file.load(repository);
+      const content = await loadP;
+      if (!content) throw new (_bitError().BitError)(`failed loading file ${file.relativePath} (ref: ${file.file.toString()}) from the model of ${this.id()}@${resolvedVersion}.
+The Source object is missing from the local scope.
+To fix, run:
+bit import ${this.id()}@${resolvedVersion} --objects --all-history`);
+      return new ClassName({
+        base: '.',
+        path: file.relativePath,
+        contents: content.contents,
+        test: file.test
+      });
+    };
+    const filesP = version.files ? Promise.all(version.files.map(loadFileInstance(_component().SourceFile))) : null;
+    // @todo: this is weird. why the scopeMeta would be taken from the current scope and not he component scope?
+    const scopeMetaP = scopeName ? _scopeMeta().default.fromScopeName(scopeName).load(repository) : Promise.resolve();
+    const log = version.log || null;
+    const [files, scopeMeta] = await Promise.all([filesP, scopeMetaP]);
+    const extensions = version.extensions.clone();
+    // when generating a new ConsumerComponent out of Version, it is critical to make sure that
+    // all objects are cloned and not copied by reference. Otherwise, every time the
+    // ConsumerComponent instance is changed, the Version will be changed as well, and since
+    // the Version instance is saved in the Repository._cache, the next time a Version instance
+    // is retrieved, it'll be different than the first time.
+    const consumerComponent = new (_legacy2().ConsumerComponent)({
+      name: this.name,
+      version: componentVersion.version,
+      scope: this.toComponentId()._legacy.scope,
+      defaultScope: this.scope,
+      lang: this.lang,
+      bindingPrefix: this.bindingPrefix,
+      mainFile: version.mainFile,
+      dependencies: this.addDepsInfoFromDepsResolver(version.dependencies, extensions),
+      devDependencies: this.addDepsInfoFromDepsResolver(version.devDependencies, extensions),
+      flattenedDependencies: version.flattenedDependencies.clone(),
+      packageDependencies: (0, _lodash().clone)(version.packageDependencies),
+      devPackageDependencies: (0, _lodash().clone)(version.devPackageDependencies),
+      peerPackageDependencies: (0, _lodash().clone)(version.peerPackageDependencies),
+      // @ts-ignore
+      files,
+      docs: version.docs,
+      // @ts-ignore
+      license: scopeMeta ? _component().License.deserialize(scopeMeta.license) : undefined,
+      // todo: make sure we have license in case of local scope
+      log,
+      overrides: _legacy3().ComponentOverrides.loadFromScope(version.overrides),
+      packageJsonChangedProps: (0, _lodash().clone)(version.packageJsonChangedProps),
+      deprecated: this.deprecated,
+      removed: version.isRemoved(),
+      scopesList: (0, _lodash().clone)(this.scopesList),
+      schema: version.schema,
+      extensions,
+      buildStatus: version.buildStatus
+    });
+    return consumerComponent;
+  }
+  addDepsInfoFromDepsResolver(dependencies, extensions) {
+    const cloned = dependencies.getClone();
+    const depsResolverData = extensions.find(ext => ext.name === 'teambit.dependencies/dependency-resolver');
+    if (!depsResolverData) return cloned;
+    cloned.forEach(dependency => {
+      if (dependency.packageName) return;
+      const matchedEntry = depsResolverData.data?.dependencies?.find(entry => {
+        return dependency.id.toString() === entry.id;
+      });
+      if (matchedEntry) {
+        dependency.packageName = matchedEntry.packageName;
+      }
+    });
+    return cloned;
+  }
+
+  // @todo: make sure it doesn't have the same ref twice, once as a version and once as a head
+  refs() {
+    const versions = Object.values(this.versionsIncludeOrphaned);
+    if (this.head) versions.push(this.head);
+    return versions;
+  }
+  validateBeforePersisting(componentStr) {
+    _legacy4().logger.trace(`validating component object: ${this.hash().hash} ${this.id()}`);
+    const component = Component.parse(componentStr);
+    component.validate();
+  }
+  toBuffer(pretty) {
+    const args = (0, _legacy5().getStringifyArgs)(pretty);
+    const obj = this.toObject();
+    const str = JSON.stringify(obj, ...args);
+    if (this.validateBeforePersist) this.validateBeforePersisting(str);
+    return Buffer.from(str);
+  }
+
+  /**
+   * Clear data that is relevant only for the local scope and should not be moved to the remote scope
+   */
+  clearStateData() {
+    this.local = false; // backward compatibility for components created before 0.12.6
+    this.state = {};
+  }
+  markVersionAsLocal(version) {
+    if (!this.state.versions) this.state = {
+      versions: {}
+    };
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    if (!this.state.versions[version]) this.state.versions[version] = {};
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    this.state.versions[version].local = true;
+  }
+
+  /**
+   * local versions that are not exported on the main lane.
+   * @see `this.getLocalTagsOrHashes()`, to get local snaps on the current lane
+   */
+  getLocalVersions() {
+    if ((0, _lodash().isEmpty)(this.state) || (0, _lodash().isEmpty)(this.state.versions)) return [];
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    return Object.keys(this.state.versions).filter(version => this.state.versions[version].local);
+  }
+  hasLocalTag(tag) {
+    const localVersions = this.getLocalVersions();
+    return localVersions.includes(tag);
+  }
+  async getLocalTagsOrHashes(repo, workspaceId, lane) {
+    const localHashes = await this.getLocalHashes(repo, workspaceId, lane);
+    if (!localHashes.length) return [];
+    return this.switchHashesWithTagsIfExist(localHashes).reverse(); // reverse to get the older first
+  }
+
+  /**
+   * Raw divergence (`snapsOnSourceOnly`). When `lane` is provided, applies the lean-lane filter:
+   * drops refs whose Version is main-origin. Those refs already live on the component's home
+   * scope (and on the destination too in the same-scope case), so `bit export` shouldn't be
+   * re-pushing them. Pass `lane` from status/export/reset to share the same "what's actually
+   * local on this lane" view.
+   *
+   * The lane's recorded head for this component is always kept, even if it's main-origin — the
+   * lane object references it and the destination scope must be able to resolve the hash. Versions
+   * marked `squashed` or `unrelated` are kept as well — they're locally-mutated and the
+   * destination needs them to reconstruct the lane history.
+   */
+  async getLocalHashes(repo, workspaceId, lane) {
+    await this.setDivergeData(repo, undefined, undefined, workspaceId);
+    const divergeData = this.getDivergeData();
+    const localHashes = divergeData.snapsOnSourceOnly;
+
+    // When there's a detached head, divergeData only includes the detached head lineage.
+    // We also need to include unexported versions from the main head lineage.
+    const hasDetachedHead = this.detachedHeads && this.detachedHeads.getAllHeads().length > 0;
+    if (hasDetachedHead && this.head) {
+      // Calculate divergence from the main head as well
+      const mainHeadDivergeData = await (0, _component2().getDivergeData)({
+        repo,
+        modelComponent: this,
+        targetHead: (this.laneId ? this.calculatedRemoteHeadWhenOnLane : this.remoteHead) || null,
+        sourceHead: this.head,
+        throws: false
+      });
+      // Add main head local versions that aren't already in localHashes
+      for (const hash of mainHeadDivergeData.snapsOnSourceOnly) {
+        if (!localHashes.find(h => h.isEqual(hash))) {
+          localHashes.push(hash);
+        }
+      }
+    }
+    if (!localHashes.length) return [];
+    const filtered = lane ? await this.filterLeanLaneRefs(repo, lane, localHashes) : localHashes;
+    return filtered.reverse(); // reverse to get the older first
+  }
+  async filterLeanLaneRefs(repo, lane, refs) {
+    const laneHead = lane.getCompHeadIncludeUpdateDependents(this.toComponentId());
+    const keptRefs = await (0, _toolboxPromise().pMapPool)(refs, async ref => {
+      if (laneHead && ref.isEqual(laneHead)) return ref;
+      const obj = await ref.load(repo);
+      if (!obj) return null;
+      const isLaneOrigin = Boolean(obj.originLaneId);
+      const isLocallyMutated = Boolean(obj.squashed) || Boolean(obj.unrelated);
+      if (!isLaneOrigin && !isLocallyMutated) return null;
+      return ref;
+    }, {
+      concurrency: (0, _harmonyModules().concurrentComponentsLimit)()
+    });
+    return keptRefs.filter(ref => ref !== null);
+  }
+
+  /**
+   * for most cases, use `isLocallyChanged`, which takes into account lanes.
+   * this is for cases when we only care about the versions exist in the `state` prop.
+   */
+  isLocallyChangedRegardlessOfLanes() {
+    return Boolean(this.getLocalVersions().length);
+  }
+
+  /**
+   * whether the component was locally changed, either by adding a new snap/tag or by merging
+   * components from different lanes.
+   */
+  async isLocallyChanged(repo, lane, workspaceId) {
+    if (lane) await this.populateLocalAndRemoteHeads(repo, lane);
+    await this.setDivergeData(repo, undefined, undefined, workspaceId);
+    const divergeData = this.getDivergeData();
+    return divergeData.isSourceAhead();
+  }
+  async getVersionHistory(repo) {
+    const emptyVersionHistory = _versionHistory().default.fromId(this.name, this.scope);
+    const versionHistory = await repo.load(emptyVersionHistory.hash());
+    return versionHistory || emptyVersionHistory;
+  }
+  async getAndPopulateVersionHistory(repo, head) {
+    const versionHistory = await this.getVersionHistory(repo);
+    const {
+      err
+    } = await this.populateVersionHistoryIfMissingGracefully(repo, versionHistory, head);
+    if (err) {
+      _legacy4().logger.error(`rethrowing an error ${err.message}, current stuck`, new Error(err.message));
+      throw err;
+    }
+    return versionHistory;
+  }
+
+  /**
+   * careful! the `versions` passed here can belong to other components, not necessarily to this one.
+   * that's why it checks whether the version-hash exists in the VersionHistory, and if it's not,
+   * it won't update it.
+   */
+  async updateRebasedVersionHistory(repo, versions) {
+    const versionHistory = await this.getVersionHistory(repo);
+    const hasUpdated = versions.some(version => {
+      const versionData = versionHistory.getVersionData(version.hash());
+      if (!versionData) return false;
+      versionHistory.addFromVersionsObjects([version]);
+      return true;
+    });
+    return hasUpdated ? versionHistory : undefined;
+  }
+  async updateVersionHistory(repo, versions) {
+    const versionHistory = await this.getVersionHistory(repo);
+    versionHistory.addFromVersionsObjects(versions);
+    _legacy4().logger.debug(`updating version history of ${this.id()} with ${versions.length} versions`);
+    return versionHistory;
+  }
+  async populateVersionHistoryIfMissingGracefully(repo, versionHistory, head,
+  /**
+   * during traversal, if a hash is found in the VersionHistory it probably means that it has all history until this
+   * point, so we can stop there for better performance. In some rare cases (e.g. the export was interrupted), we
+   * need the ability of full traversal to repair the VersionHistory.
+   */
+  exitWhenFind = true) {
+    const headExists = versionHistory.hasHash(head);
+    if (exitWhenFind && headExists) return {};
+    const getVersionObj = async ref => await ref.load(repo);
+    const versionsToAdd = [];
+    let err;
+    const addParentsRecursively = async version => {
+      await (0, _pMapSeries().default)(version.parents, async parent => {
+        const foundParent = versionHistory.hasHash(parent) || versionsToAdd.find(v => v.hash().isEqual(parent));
+        if (exitWhenFind && foundParent) {
+          return;
+        }
+        const parentVersion = await getVersionObj(parent);
+        if (!parentVersion) {
+          const tag = this.getTagOfRefIfExists(parent);
+          err = tag ? new (_legacy6().VersionNotFound)(tag, this.id()) : new (_legacy6().ParentNotFound)(this.id(), version.hash().toString(), parent.toString());
+          return;
+        }
+        versionsToAdd.push(parentVersion);
+        await addParentsRecursively(parentVersion);
+      });
+    };
+    const headVer = await getVersionObj(head);
+    if (!headVer) {
+      return {
+        err: new (_legacy6().HeadNotFound)(this.id(), head.toString())
+      };
+    }
+    return this.populateVersionHistoryMutex.runExclusive(async () => {
+      if (!headExists) versionsToAdd.push(headVer);
+      await addParentsRecursively(headVer);
+      const added = versionsToAdd.map(v => (0, _component2().getVersionParentsFromVersion)(v));
+      if (err) {
+        return {
+          err,
+          added
+        };
+      }
+      versionHistory.addFromVersionsObjects(versionsToAdd);
+      _legacy4().logger.debug(`populateVersionHistoryIfMissingGracefully, updating ${this.id()} with ${versionsToAdd.length} versions`);
+      await repo.writeObjectsToTheFS([versionHistory]);
+      return {
+        added
+      };
+    });
+  }
+  static parse(contents) {
+    const rawComponent = JSON.parse(contents);
+    return Component.from({
+      name: rawComponent.box ? `${rawComponent.box}/${rawComponent.name}` : rawComponent.name,
+      scope: rawComponent.scope,
+      versions: (0, _lodash().mapValues)(rawComponent.versions, val => _objects().Ref.from(val)),
+      lang: rawComponent.lang,
+      deprecated: rawComponent.deprecated,
+      bindingPrefix: rawComponent.bindingPrefix,
+      state: rawComponent.state,
+      orphanedVersions: (0, _lodash().mapValues)(rawComponent.orphanedVersions || {}, val => _objects().Ref.from(val)),
+      scopesList: rawComponent.remotes,
+      head: rawComponent.head ? _objects().Ref.from(rawComponent.head) : undefined,
+      schema: rawComponent.schema || (rawComponent.head ? _legacy2().SchemaName.Harmony : _legacy2().SchemaName.Legacy),
+      detachedHeads: _detachHeads().DetachedHeads.fromObject(rawComponent.detachedHeads)
+    });
+  }
+  static from(props) {
+    return new Component(props);
+  }
+  static fromBitId(bitId) {
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    return new Component({
+      name: bitId.fullName,
+      scope: bitId.scope
+    });
+  }
+  get isLegacy() {
+    return !this.schema || this.schema === _legacy2().SchemaName.Legacy;
+  }
+  validate() {
+    const message = `unable to save Component object "${this.id()}"`;
+    if (!this.name) throw new (_bitError().BitError)(`${message} the name is missing`);
+    if (this.state && this.state.versions) {
+      Object.keys(this.state.versions).forEach(version => {
+        if ((0, _componentVersion().isTag)(version) && !this.hasTag(version)) {
+          throw new (_legacyCli().ValidationError)(`${message}, the version ${version} is marked as staged but is not available`);
+        }
+      });
+    }
+    const hashDuplications = (0, _toolboxArray().findDuplications)(this.versionArray.map(v => v.toString()));
+    if (hashDuplications.length) {
+      throw new (_legacyCli().ValidationError)(`${message}, the following hash(es) are duplicated ${hashDuplications.join(', ')}`);
+    }
+    Object.keys(this.orphanedVersions).forEach(version => {
+      if (this.versions[version]) {
+        throw new (_legacyCli().ValidationError)(`${message}, the version "${version}" exists in orphanedVersions but it exits also in "versions" prop`);
+      }
+    });
+    if (!this.isLegacy && !this.head && this.versionArray.length) {
+      // legacy don't have head. also, when snapping on a lane the first time, there is no head.
+      // tags are done on default lane only, so if there are versions (tag), it must have head
+      throw new (_legacyCli().ValidationError)(`${message}, the "head" prop is missing`);
+    }
+  }
+}
+exports.default = Component;
+
+//# sourceMappingURL=model-component.js.map