@teambit/objects 0.0.19

package/dist/models/version.js

@@ -0,0 +1,777 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _componentVersion() {
+  const data = require("@teambit/component-version");
+  _componentVersion = function () {
+    return data;
+  };
+  return data;
+}
+function _componentId() {
+  const data = require("@teambit/component-id");
+  _componentId = function () {
+    return data;
+  };
+  return data;
+}
+function _laneId() {
+  const data = require("@teambit/lane-id");
+  _laneId = function () {
+    return data;
+  };
+  return data;
+}
+function _uuid() {
+  const data = require("uuid");
+  _uuid = 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.extension-data");
+  _legacy3 = 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 _toolboxCrypto() {
+  const data = require("@teambit/toolbox.crypto.sha1");
+  _toolboxCrypto = function () {
+    return data;
+  };
+  return data;
+}
+function _objects() {
+  const data = require("../objects");
+  _objects = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy6() {
+  const data = require("@teambit/legacy.scope");
+  _legacy6 = function () {
+    return data;
+  };
+  return data;
+}
+function _source() {
+  const data = _interopRequireDefault(require("./source"));
+  _source = function () {
+    return data;
+  };
+  return data;
+}
+function _dependenciesGraph() {
+  const data = require("./dependencies-graph");
+  _dependenciesGraph = function () {
+    return data;
+  };
+  return data;
+}
+function _bit() {
+  const data = require("@teambit/bit.get-bit-version");
+  _bit = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: 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); }
+/**
+ * Represent a version model in the scope
+ */
+class Version extends _objects().BitObject {
+  // whether the version is hidden from commands such as "bit log", "bit blame". (needed for un-meaningful snaps, such as merged-lane snap prior to the tag)
+
+  constructor(props) {
+    super();
+    _defineProperty(this, "mainFile", void 0);
+    _defineProperty(this, "files", void 0);
+    _defineProperty(this, "log", void 0);
+    _defineProperty(this, "docs", void 0);
+    _defineProperty(this, "dependencies", void 0);
+    _defineProperty(this, "devDependencies", void 0);
+    _defineProperty(this, "peerDependencies", void 0);
+    _defineProperty(this, "flattenedDependencies", void 0);
+    _defineProperty(this, "dependenciesGraphRef", void 0);
+    _defineProperty(this, "_dependenciesGraph", void 0);
+    // caching for the dependencies graph
+    _defineProperty(this, "flattenedEdgesRef", void 0);
+    // ref to a BitObject Source file, which is a JSON object containing the flattened edge
+    _defineProperty(this, "_flattenedEdges", void 0);
+    // caching for the flattenedEdges
+    /**
+     * @deprecated
+     * to get the flattenedEdges, please use `this.getFlattenedEdges()`.
+     * this function handles the backward compatibility and provides the flattened edges regardless whether it was saved
+     * the `flattenedEdgesRef` introduced or after.
+     *
+     * the reason this is left here is not for backward compatibility, but for forward compatibility. meaning, if a
+     * Version object created by the new version is parsed by an old version that doesn't support the flattenedEdgesRef,
+     * then, it'll be able to still get the flattenedEdges by this prop.
+     * this is causing duplication currently. the data is kept in both, `this.flattenedEdges` and the file stored in `flattenedEdgesRef`.
+     * so it'll be best to delete this prop as soon as all scopes are deployed with the new version.
+     * (around August 2023 should be safe)
+     */
+    _defineProperty(this, "flattenedEdges", void 0);
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    _defineProperty(this, "packageDependencies", void 0);
+    _defineProperty(this, "devPackageDependencies", void 0);
+    _defineProperty(this, "peerPackageDependencies", void 0);
+    _defineProperty(this, "bindingPrefix", void 0);
+    _defineProperty(this, "schema", void 0);
+    _defineProperty(this, "overrides", void 0);
+    _defineProperty(this, "packageJsonChangedProps", void 0);
+    _defineProperty(this, "_hash", void 0);
+    // reason for the underscore prefix is that we already have hash as a method
+    _defineProperty(this, "parents", void 0);
+    _defineProperty(this, "squashed", void 0);
+    // when a component is squashed during lane-merge
+    _defineProperty(this, "unrelated", void 0);
+    // when a component from a lane was created with the same name/scope as main, this ref points to the component of the lane
+    _defineProperty(this, "extensions", void 0);
+    _defineProperty(this, "buildStatus", void 0);
+    _defineProperty(this, "componentId", void 0);
+    // can help debugging errors when validating Version object
+    _defineProperty(this, "bitVersion", void 0);
+    _defineProperty(this, "modified", []);
+    // currently mutation could happen as a result of either "squash" or "sign".
+    _defineProperty(this, "origin", void 0);
+    // for debugging purposes
+    _defineProperty(this, "hidden", void 0);
+    this.mainFile = props.mainFile;
+    this.files = props.files;
+    this.log = props.log;
+    this.dependencies = new (_legacy2().Dependencies)(props.dependencies);
+    this.devDependencies = new (_legacy2().Dependencies)(props.devDependencies);
+    this.peerDependencies = new (_legacy2().Dependencies)(props.peerDependencies);
+    this.docs = props.docs;
+    this.flattenedDependencies = props.flattenedDependencies || new (_componentId().ComponentIdList)();
+    this.flattenedEdges = props.flattenedEdges || [];
+    this.flattenedEdgesRef = props.flattenedEdgesRef;
+    this.dependenciesGraphRef = props.dependenciesGraphRef;
+    this.packageDependencies = props.packageDependencies || {};
+    this.devPackageDependencies = props.devPackageDependencies || {};
+    this.peerPackageDependencies = props.peerPackageDependencies || {};
+    this.bindingPrefix = props.bindingPrefix;
+    this.schema = props.schema;
+    this.overrides = props.overrides || {};
+    this.packageJsonChangedProps = props.packageJsonChangedProps || {};
+    // @ts-ignore yes, props.hash can be undefined here, but it gets populated as soon as Version is created
+    this._hash = props.hash;
+    this.parents = props.parents || [];
+    this.squashed = props.squashed;
+    this.unrelated = props.unrelated;
+    this.extensions = props.extensions || _legacy3().ExtensionDataList.fromArray([]);
+    this.buildStatus = props.buildStatus;
+    this.componentId = props.componentId;
+    this.bitVersion = props.bitVersion;
+    this.modified = props.modified || [];
+    this.origin = props.origin;
+    this.hidden = props.hidden;
+    this.validateVersion();
+  }
+
+  /**
+   * use only this method to get the flattened edges (graph of flattened dependencies).
+   * it's backward compatible with the previous way this was stored on the Version object itself.
+   */
+  async getFlattenedEdges(repo) {
+    const getWithBackwardCompatibility = async () => {
+      if (this.flattenedEdgesRef) {
+        // it's possible that there is a ref but the file is not there.
+        // it can happen if the remote-scope uses an older version that doesn't know to collect this ref.
+        // in which case, the client will get the Version object with the ref prop, but not the Source object.
+        const throws = false;
+        const flattenedEdgesSource = await repo.load(this.flattenedEdgesRef, throws);
+        if (flattenedEdgesSource) {
+          const flattenedEdgesJson = JSON.parse(flattenedEdgesSource.contents.toString());
+          return flattenedEdgesJson.map(item => Array.isArray(item) ? Version.depEdgeFromArray(item) : Version.depEdgeFromObject(item));
+        }
+      }
+      return this.flattenedEdges || [];
+    };
+    if (!this._flattenedEdges) {
+      this._flattenedEdges = await getWithBackwardCompatibility();
+    }
+    return this._flattenedEdges;
+  }
+  async loadDependenciesGraph(repo) {
+    if (!this._dependenciesGraph) {
+      if (this.dependenciesGraphRef) {
+        // it's possible that there is a ref but the file is not there.
+        // it can happen if the remote-scope uses an older version that doesn't know to collect this ref.
+        // in which case, the client will get the Version object with the ref prop, but not the Source object.
+        const throws = false;
+        const dependenciesGraphSource = await repo.load(this.dependenciesGraphRef, throws);
+        if (dependenciesGraphSource) {
+          this._dependenciesGraph = _dependenciesGraph().DependenciesGraph.deserialize(dependenciesGraphSource.contents.toString());
+        }
+      }
+    }
+    return this._dependenciesGraph;
+  }
+  validateVersion() {
+    const nonEmptyFields = ['mainFile', 'files'];
+    nonEmptyFields.forEach(field => {
+      if (!this[field]) {
+        throw new (_legacy6().VersionInvalid)(`failed creating a version object, the field "${field}" can't be empty`);
+      }
+    });
+  }
+  id() {
+    const obj = this.toObject();
+
+    // @todo: remove the entire dependencies.relativePaths from the ID (it's going to be a breaking change)
+    const getDependencies = deps => {
+      const clonedDependencies = deps.cloneAsString();
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      return clonedDependencies.map(dependency => {
+        return {
+          id: dependency.id,
+          relativePaths: dependency.relativePaths.map(relativePath => {
+            return {
+              sourceRelativePath: relativePath.sourceRelativePath,
+              destinationRelativePath: relativePath.destinationRelativePath
+            };
+          })
+        };
+      });
+    };
+    const getExtensions = extensions => {
+      const sortedConfigOnly = extensions.sortById().toConfigArray();
+      return sortedConfigOnly;
+    };
+    const filterFunction = (val, key) => {
+      if (key === 'devDependencies' || key === 'extensionDependencies' || key === 'devPackageDependencies' || key === 'peerPackageDependencies' || key === 'overrides' || key === 'extensions') {
+        return !(0, _lodash().isEmpty)(val);
+      }
+      return !!val;
+    };
+    return JSON.stringify((0, _lodash().pickBy)({
+      mainFile: obj.mainFile,
+      files: obj.files,
+      log: obj.log,
+      dependencies: getDependencies(this.dependencies),
+      devDependencies: getDependencies(this.devDependencies),
+      extensionDependencies: getDependencies(this.extensionDependencies),
+      packageDependencies: obj.packageDependencies,
+      devPackageDependencies: obj.devPackageDependencies,
+      peerPackageDependencies: obj.peerPackageDependencies,
+      bindingPrefix: obj.bindingPrefix,
+      overrides: obj.overrides,
+      extensions: getExtensions(this.extensions)
+    }, filterFunction));
+  }
+  calculateHash() {
+    return new (_objects().Ref)(_objects().BitObject.makeHash(this.id()));
+  }
+  hash() {
+    if (!this._hash) {
+      throw new Error('hash is missing from a Version object');
+    }
+    return new (_objects().Ref)(this._hash);
+  }
+  get extensionDependencies() {
+    return new (_legacy2().Dependencies)(this.extensions.extensionsBitIds.map(id => new (_legacy2().Dependency)(id, [])));
+  }
+  lastModified() {
+    if (!this.modified || !this.modified.length) return this.log.date;
+    return this.modified[this.modified.length - 1].date;
+  }
+  getAllFlattenedDependencies() {
+    return _componentId().ComponentIdList.fromArray([...this.flattenedDependencies]);
+  }
+  getAllDependencies() {
+    return [...this.dependencies.dependencies, ...this.devDependencies.dependencies, ...this.extensionDependencies.dependencies];
+  }
+  get depsIdsGroupedByType() {
+    return {
+      dependencies: this.dependencies.getAllIds(),
+      devDependencies: this.devDependencies.getAllIds(),
+      peerDependencies: this.peerDependencies.getAllIds(),
+      extensionDependencies: this.extensions.extensionsBitIds
+    };
+  }
+  getAllDependenciesCloned() {
+    const dependencies = [...this.dependencies.getClone(), ...this.devDependencies.getClone()];
+    return new (_legacy2().Dependencies)(dependencies);
+  }
+  getAllDependenciesIds() {
+    const allDependencies = Object.values(this.depsIdsGroupedByType).flat();
+    return _componentId().ComponentIdList.fromArray(allDependencies);
+  }
+  getDependenciesIdsExcludeExtensions() {
+    return _componentId().ComponentIdList.fromArray([...this.dependencies.getAllIds(), ...this.devDependencies.getAllIds()]);
+  }
+  updateFlattenedDependency(currentId, newId) {
+    const getUpdated = flattenedDependencies => {
+      const updatedIds = flattenedDependencies.map(depId => {
+        if (depId.isEqual(currentId)) return newId;
+        return depId;
+      });
+      return _componentId().ComponentIdList.fromArray(updatedIds);
+    };
+    this.flattenedDependencies = getUpdated(this.flattenedDependencies);
+  }
+  refs() {
+    return this.refsWithOptions();
+  }
+  refsWithOptions(includeParents = true, includeArtifacts = true) {
+    const allRefs = [];
+    const extractRefsFromFiles = files => {
+      const refs = files ? files.map(file => file.file) : [];
+      return refs;
+    };
+    const files = extractRefsFromFiles(this.files);
+    allRefs.push(...files);
+    if (includeParents) {
+      allRefs.push(...this.parents);
+    }
+    if (includeArtifacts) {
+      const artifacts = (0, _component().getRefsFromExtensions)(this.extensions);
+      allRefs.push(...artifacts);
+    }
+    if (this.flattenedEdgesRef) allRefs.push(this.flattenedEdgesRef);
+    if (this.dependenciesGraphRef) allRefs.push(this.dependenciesGraphRef);
+    return allRefs;
+  }
+  refsWithoutParents() {
+    const extractRefsFromFiles = files => {
+      const refs = files ? files.map(file => file.file) : [];
+      return refs;
+    };
+    const files = extractRefsFromFiles(this.files);
+    const artifacts = (0, _component().getRefsFromExtensions)(this.extensions);
+    return [...files, ...artifacts].filter(ref => ref);
+  }
+  async collectManyObjects(repo, refs) {
+    return repo.loadManyRaw(refs);
+  }
+  static depEdgeToObject(depEdge) {
+    return {
+      source: depEdge.source.serialize(),
+      target: depEdge.target.serialize(),
+      type: depEdge.type
+    };
+  }
+  static depEdgeFromObject(depEdgeObj) {
+    return {
+      source: _componentId().ComponentID.fromObject(depEdgeObj.source),
+      target: _componentId().ComponentID.fromObject(depEdgeObj.target),
+      type: depEdgeObj.type
+    };
+  }
+  static depEdgeToArray(depEdge) {
+    return [depEdge.source.toString(), depEdge.target.toString(), depEdge.type];
+  }
+  static depEdgeFromArray(depEdgeArr) {
+    const [sourceStr, targetStr, type] = depEdgeArr;
+    return {
+      source: _componentId().ComponentID.fromString(sourceStr),
+      target: _componentId().ComponentID.fromString(targetStr),
+      type: type
+    };
+  }
+  static flattenedEdgeToSource(flattenedEdges) {
+    if (!flattenedEdges) return undefined;
+    // @todo: around August 2024, uncomment this line and delete the next one.
+    // it'll make this object much much smaller (for 604 edges, it's now 143KB, with the array format it's 6KB!)
+    // const flattenedEdgesObj = flattenedEdges.map((f) => Version.depEdgeToArray(f));
+    const flattenedEdgesObj = flattenedEdges.map(f => Version.depEdgeToObject(f));
+    const flattenedEdgesBuffer = Buffer.from(JSON.stringify(flattenedEdgesObj));
+    return _source().default.from(flattenedEdgesBuffer);
+  }
+  static dependenciesGraphToSource(dependenciesGraph) {
+    if (!dependenciesGraph) return undefined;
+    const dependenciesGraphBuffer = Buffer.from(dependenciesGraph.serialize());
+    return _source().default.from(dependenciesGraphBuffer);
+  }
+  toObject() {
+    const _convertFileToObject = file => {
+      return {
+        file: file.file.toString(),
+        relativePath: file.relativePath,
+        name: file.name,
+        test: file.test
+      };
+    };
+    return (0, _lodash().pickBy)({
+      files: this.files ? this.files.map(_convertFileToObject) : null,
+      mainFile: this.mainFile,
+      bindingPrefix: this.bindingPrefix,
+      schema: this.schema,
+      log: {
+        message: this.log.message,
+        date: this.log.date,
+        username: this.log.username,
+        email: this.log.email
+      },
+      docs: this.docs,
+      dependencies: this.dependencies.cloneAsObject(),
+      devDependencies: this.devDependencies.cloneAsObject(),
+      flattenedDependencies: this.flattenedDependencies.map(dep => dep.toObject()),
+      flattenedEdges: this.flattenedEdgesRef ? undefined : this.flattenedEdges.map(f => Version.depEdgeToObject(f)),
+      flattenedEdgesRef: this.flattenedEdgesRef?.toString(),
+      dependenciesGraphRef: this.dependenciesGraphRef?.toString(),
+      extensions: this.extensions.toModelObjects(),
+      packageDependencies: this.packageDependencies,
+      devPackageDependencies: this.devPackageDependencies,
+      peerPackageDependencies: this.peerPackageDependencies,
+      overrides: this.overrides,
+      buildStatus: this.buildStatus,
+      packageJsonChangedProps: this.packageJsonChangedProps,
+      parents: this.parents.map(p => p.toString()),
+      squashed: this.squashed ? {
+        previousParents: this.squashed.previousParents.map(p => p.toString()),
+        laneId: this.squashed.laneId.toObject()
+      } : undefined,
+      unrelated: this.unrelated ? {
+        head: this.unrelated.head.toString(),
+        laneId: this.unrelated.laneId.toObject()
+      } : undefined,
+      bitVersion: this.bitVersion,
+      modified: this.modified,
+      origin: this.origin,
+      hidden: this.hidden
+    }, val => !!val);
+  }
+  validateBeforePersisting(versionStr) {
+    _legacy4().logger.trace(`validating version object, hash: ${this.hash().hash}`);
+    const version = Version.parse(versionStr, this._hash);
+    version.validate();
+  }
+  toBuffer(pretty) {
+    const obj = this.toObject();
+    const args = (0, _legacy5().getStringifyArgs)(pretty);
+    const str = JSON.stringify(obj, ...args);
+    if (this.validateBeforePersist) this.validateBeforePersisting(str);
+    return Buffer.from(str);
+  }
+  /**
+   * used by the super class BitObject
+   */
+  static parse(contents, hash) {
+    const contentParsed = JSON.parse(contents);
+    const {
+      mainFile,
+      files,
+      bindingPrefix,
+      schema,
+      log,
+      docs,
+      dependencies,
+      devDependencies,
+      flattenedDependencies,
+      flattenedEdges,
+      flattenedEdgesRef,
+      dependenciesGraphRef,
+      flattenedDevDependencies,
+      devPackageDependencies,
+      peerPackageDependencies,
+      packageDependencies,
+      overrides,
+      packageJsonChangedProps,
+      extensions,
+      buildStatus,
+      parents,
+      squashed,
+      unrelated,
+      bitVersion,
+      modified,
+      origin,
+      hidden
+    } = contentParsed;
+    const _getDependencies = (deps = []) => {
+      const getRelativePath = relativePath => {
+        if (relativePath.importSpecifiers) {
+          // backward compatibility. Before the massive validation was added, an item of
+          // relativePath.importSpecifiers array could be missing the mainFile property, which is
+          // an invalid ImportSpecifier. (instead the mainFile it had another importSpecifiers object).
+          relativePath.importSpecifiers = relativePath.importSpecifiers.filter(importSpecifier => importSpecifier.mainFile);
+          if (!relativePath.importSpecifiers.length) delete relativePath.importSpecifiers;
+        }
+        return relativePath;
+      };
+      return deps.map(dependency => {
+        if (!dependency.id.scope) {
+          throw new (_legacy6().BitIdCompIdError)(dependency.id.name);
+        }
+        return new (_legacy2().Dependency)(_componentId().ComponentID.fromObject(dependency.id), Array.isArray(dependency.relativePaths) ? dependency.relativePaths.map(getRelativePath) : dependency.relativePaths);
+      });
+    };
+    const _getFlattenedDependencies = (deps = []) => {
+      return deps.map(dep => _componentId().ComponentID.fromObject(dep));
+    };
+    const _groupFlattenedDependencies = () => {
+      // support backward compatibility. until v15, there was both flattenedDependencies and
+      // flattenedDevDependencies. since then, these both were grouped to one flattenedDependencies
+      const flattenedDeps = _getFlattenedDependencies(flattenedDependencies);
+      const flattenedDevDeps = _getFlattenedDependencies(flattenedDevDependencies);
+      return _componentId().ComponentIdList.fromArray([...flattenedDeps, ...flattenedDevDeps]);
+    };
+    const parseFile = file => {
+      return {
+        file: _objects().Ref.from(file.file),
+        relativePath: file.relativePath,
+        name: file.name,
+        test: file.test
+      };
+    };
+    const _getExtensions = (exts = []) => {
+      if (exts.length) {
+        const newExts = exts.map(extension => {
+          if (extension.extensionId) {
+            const extensionId = _componentId().ComponentID.fromObject(extension.extensionId);
+            const entry = new (_legacy3().ExtensionDataEntry)(undefined, extensionId, undefined, extension.config, extension.data);
+            return entry;
+          }
+          const entry = new (_legacy3().ExtensionDataEntry)(extension.id, undefined, extension.name, extension.config, extension.data);
+          return entry;
+        });
+        return _legacy3().ExtensionDataList.fromModelObject(newExts);
+      }
+      return new (_legacy3().ExtensionDataList)();
+    };
+    return new Version({
+      mainFile,
+      files: files.map(parseFile),
+      bindingPrefix,
+      schema: schema || undefined,
+      log: {
+        // workaround for a bug where the log.message was saved as boolean when running `bit tag -m ""`
+        // the bug was fixed since v0.1.27, but old objects might still have this bug
+        message: typeof log.message !== 'string' ? '' : log.message,
+        date: log.date,
+        username: log.username,
+        email: log.email
+      },
+      docs,
+      dependencies: _getDependencies(dependencies),
+      devDependencies: _getDependencies(devDependencies),
+      flattenedDependencies: _groupFlattenedDependencies(),
+      // backward compatibility. before introducing `flattenedEdgesRef`, we only had `flattenedEdges`. see getFlattenedEdges() for more info.
+      flattenedEdges: flattenedEdgesRef ? [] : flattenedEdges?.map(f => Version.depEdgeFromObject(f)) || [],
+      flattenedEdgesRef: flattenedEdgesRef ? _objects().Ref.from(flattenedEdgesRef) : undefined,
+      dependenciesGraphRef: dependenciesGraphRef ? _objects().Ref.from(dependenciesGraphRef) : undefined,
+      devPackageDependencies,
+      peerPackageDependencies,
+      packageDependencies,
+      overrides,
+      packageJsonChangedProps,
+      hash,
+      parents: parents ? parents.map(p => _objects().Ref.from(p)) : [],
+      squashed: squashed ? {
+        previousParents: squashed.previousParents.map(r => _objects().Ref.from(r)),
+        laneId: new (_laneId().LaneId)(squashed.laneId)
+      } : undefined,
+      unrelated: unrelated ? {
+        head: _objects().Ref.from(unrelated.head),
+        laneId: new (_laneId().LaneId)(unrelated.laneId)
+      } : undefined,
+      extensions: _getExtensions(extensions),
+      buildStatus,
+      bitVersion,
+      modified,
+      origin,
+      hidden
+    });
+  }
+
+  /**
+   * used by raw-object.toRealObject()
+   */
+  static from(versionProps, hash) {
+    return Version.parse(JSON.stringify(versionProps), hash);
+  }
+
+  /**
+   * Create version model object from consumer component
+   * @param {*} param0
+   */
+  static fromComponent({
+    component,
+    files,
+    flattenedEdges,
+    dependenciesGraph
+  }) {
+    const parseFile = file => {
+      return {
+        file: file.file.hash(),
+        relativePath: file.relativePath,
+        name: file.name,
+        test: file.test
+      };
+    };
+    if (!component.log) throw new Error('Version.fromComponent - component.log is missing');
+    const version = new Version({
+      mainFile: (0, _legacy5().pathNormalizeToLinux)(component.mainFile),
+      files: files.map(parseFile),
+      bindingPrefix: component.bindingPrefix,
+      log: component.log,
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      docs: component.docs,
+      dependencies: component.dependencies.get(),
+      devDependencies: component.devDependencies.get(),
+      packageDependencies: component.packageDependencies,
+      devPackageDependencies: component.devPackageDependencies,
+      peerPackageDependencies: component.peerPackageDependencies,
+      dependenciesGraphRef: dependenciesGraph?.hash(),
+      flattenedDependencies: component.flattenedDependencies,
+      // it's safe to remove this line once the version.flattenedEdges prop is deleted
+      flattenedEdges: component.flattenedEdges,
+      flattenedEdgesRef: flattenedEdges?.hash(),
+      schema: component.schema,
+      overrides: component.overrides.componentOverridesData,
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      packageJsonChangedProps: component.packageJsonChangedProps,
+      extensions: component.extensions,
+      buildStatus: component.buildStatus,
+      componentId: component.id,
+      bitVersion: (0, _bit().getBitVersion)()
+    });
+    if ((0, _componentVersion().isSnap)(component.version)) {
+      version._hash = component.version;
+    } else {
+      version.setNewHash();
+    }
+    return version;
+  }
+  setNewHash() {
+    this._hash = (0, _toolboxCrypto().sha1)((0, _uuid().v4)());
+  }
+  get ignoreSharedDir() {
+    return !(0, _legacy2().isSchemaSupport)(_legacy2().SchemaFeature.sharedDir, this.schema);
+  }
+  get isLegacy() {
+    return !this.schema || this.schema === _legacy2().SchemaName.Legacy;
+  }
+  get originLaneId() {
+    return this.origin?.lane ? new (_laneId().LaneId)({
+      name: this.origin.lane.name,
+      scope: this.origin.lane.scope
+    }) : undefined;
+  }
+  get originId() {
+    return this.origin?.id ? _componentId().ComponentID.fromObject({
+      scope: this.origin.id.scope,
+      name: this.origin.id.name
+    }) : undefined;
+  }
+  setDist(dist) {
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    this.dist = dist ? {
+      file: dist.hash(),
+      name: _legacy().DEFAULT_BUNDLE_FILENAME
+    } : null;
+  }
+  hasParent(ref) {
+    return this.parents.find(p => p.toString() === ref.toString());
+  }
+  addParent(ref) {
+    if (this.isLegacy) return;
+    if (this.hasParent(ref)) {
+      return; // make sure to not add twice
+    }
+    this.parents.push(ref);
+  }
+  setSquashed(squashData, log, replaceMessage) {
+    this.squashed = squashData;
+    this.addModifiedLog(log);
+    if (replaceMessage) {
+      this.addModifiedLog({
+        username: undefined,
+        email: undefined,
+        date: Date.now().toString(),
+        message: `squashing: replacing the original log.message, which was: "${this.log.message || '<empty>'}"`
+      });
+      this.log.message = replaceMessage;
+    }
+  }
+  setUnrelated(externalHead) {
+    this.unrelated = externalHead;
+  }
+  addModifiedLog(log) {
+    this.modified.push(log);
+  }
+  addAsOnlyParent(ref) {
+    if (this.isLegacy) return;
+    this.parents = [ref];
+  }
+  removeParent(ref) {
+    this.parents = this.parents.filter(p => p.toString() !== ref.toString());
+  }
+  removeAllParents() {
+    this.parents = [];
+  }
+  modelFilesToSourceFiles(repository) {
+    return Promise.all(this.files.map(file => _component().SourceFile.loadFromSourceFileModel(file, repository)));
+  }
+  isRemoved() {
+    return Boolean(this.extensions.findCoreExtension(_legacy().Extensions.remove)?.config?.removed);
+  }
+  shouldRemoveFromMain() {
+    return Boolean(this.extensions.findCoreExtension(_legacy().Extensions.remove)?.config?.removeOnMain);
+  }
+
+  /**
+   * Validate the version model properties, to make sure we are not inserting something
+   * in the wrong format
+   */
+  validate() {
+    (0, _legacy6().validateVersionInstance)(this);
+  }
+}
+exports.default = Version;
+
+//# sourceMappingURL=version.js.map