@teambit/objects 0.0.19

package/dist/models/lane-history.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_uuid","data","require","_legacy","_harmonyModules","_objects","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","_toPropertyKey","value","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","LaneHistory","BitObject","constructor","props","name","scope","laneHash","history","id","fromLaneObject","laneObject","hash","toString","toObject","pretty","args","getStringifyArgs","JSON","stringify","toBuffer","Buffer","from","getHistory","addHistory","laneObj","msg","log","getBasicLog","message","components","toComponentIds","toStringArray","deleted","c","isDeleted","map","changeVersion","head","v4","merge","laneHistory","create","parse","contents","parsed","exports"],"sources":["lane-history.ts"],"sourcesContent":["import { v4 } from 'uuid';\nimport { getStringifyArgs } from '@teambit/legacy.utils';\nimport { getBasicLog } from '@teambit/harmony.modules.get-basic-log';\nimport { BitObject } from '../objects';\nimport Lane from './lane';\n\ntype Log = { date: string; username?: string; email?: string; message?: string };\n\nexport type HistoryItem = {\n  log: Log;\n  components: string[];\n  deleted?: string[];\n};\n\ntype History = { [uuid: string]: HistoryItem };\n\ntype LaneHistoryProps = {\n  name: string;\n  scope: string;\n  laneHash: string;\n  history: History;\n};\n\nexport class LaneHistory extends BitObject {\n  private name: string;\n  private scope: string;\n  private laneHash: string;\n  private history: History;\n\n  constructor(props: LaneHistoryProps) {\n    super();\n    this.name = props.name;\n    this.scope = props.scope;\n    this.laneHash = props.laneHash;\n    this.history = props.history;\n  }\n\n  id() {\n    return `${this.laneHash}:${LaneHistory.name}`;\n  }\n\n  static fromLaneObject(laneObject: Lane): LaneHistory {\n    return new LaneHistory({\n      scope: laneObject.scope,\n      name: laneObject.name,\n      laneHash: laneObject.hash().toString(),\n      history: {},\n    });\n  }\n\n  toObject(): Record<string, any> {\n    return {\n      name: this.name,\n      scope: this.scope,\n      laneHash: this.laneHash,\n      history: this.history,\n    };\n  }\n\n  toString(pretty: boolean): string {\n    const args = getStringifyArgs(pretty);\n    return JSON.stringify(this.toObject(), ...args);\n  }\n\n  toBuffer(pretty): Buffer {\n    return Buffer.from(this.toString(pretty));\n  }\n\n  getHistory(): History {\n    return this.history;\n  }\n\n  async addHistory(laneObj: Lane, msg?: string) {\n    const log: Log = await getBasicLog();\n    if (msg) log.message = msg;\n    const components = laneObj.toComponentIds().toStringArray();\n    const deleted = laneObj.components\n      .filter((c) => c.isDeleted)\n      .map((c) => c.id.changeVersion(c.head.toString()).toString());\n    this.history[v4()] = { log, components, ...(deleted.length && { deleted }) };\n  }\n\n  merge(laneHistory: LaneHistory) {\n    this.history = { ...this.history, ...laneHistory.history };\n  }\n\n  static create(name: string, scope: string, laneHash: string) {\n    return new LaneHistory({\n      name,\n      scope,\n      laneHash,\n      history: {},\n    });\n  }\n\n  static parse(contents: string): LaneHistory {\n    const parsed = JSON.parse(contents);\n    const props: LaneHistoryProps = {\n      name: parsed.name,\n      scope: parsed.scope,\n      laneHash: parsed.laneHash,\n      history: parsed.history,\n    };\n    return new LaneHistory(props);\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,MAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,KAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,QAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,OAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,gBAAA;EAAA,MAAAH,IAAA,GAAAC,OAAA;EAAAE,eAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAI,SAAA;EAAA,MAAAJ,IAAA,GAAAC,OAAA;EAAAG,QAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAuC,SAAAK,QAAAC,CAAA,EAAAC,CAAA,QAAAC,CAAA,GAAAC,MAAA,CAAAC,IAAA,CAAAJ,CAAA,OAAAG,MAAA,CAAAE,qBAAA,QAAAC,CAAA,GAAAH,MAAA,CAAAE,qBAAA,CAAAL,CAAA,GAAAC,CAAA,KAAAK,CAAA,GAAAA,CAAA,CAAAC,MAAA,WAAAN,CAAA,WAAAE,MAAA,CAAAK,wBAAA,CAAAR,CAAA,EAAAC,CAAA,EAAAQ,UAAA,OAAAP,CAAA,CAAAQ,IAAA,CAAAC,KAAA,CAAAT,CAAA,EAAAI,CAAA,YAAAJ,CAAA;AAAA,SAAAU,cAAAZ,CAAA,aAAAC,CAAA,MAAAA,CAAA,GAAAY,SAAA,CAAAC,MAAA,EAAAb,CAAA,UAAAC,CAAA,WAAAW,SAAA,CAAAZ,CAAA,IAAAY,SAAA,CAAAZ,CAAA,QAAAA,CAAA,OAAAF,OAAA,CAAAI,MAAA,CAAAD,CAAA,OAAAa,OAAA,WAAAd,CAAA,IAAAe,eAAA,CAAAhB,CAAA,EAAAC,CAAA,EAAAC,CAAA,CAAAD,CAAA,SAAAE,MAAA,CAAAc,yBAAA,GAAAd,MAAA,CAAAe,gBAAA,CAAAlB,CAAA,EAAAG,MAAA,CAAAc,yBAAA,CAAAf,CAAA,KAAAH,OAAA,CAAAI,MAAA,CAAAD,CAAA,GAAAa,OAAA,WAAAd,CAAA,IAAAE,MAAA,CAAAgB,cAAA,CAAAnB,CAAA,EAAAC,CAAA,EAAAE,MAAA,CAAAK,wBAAA,CAAAN,CAAA,EAAAD,CAAA,iBAAAD,CAAA;AAAA,SAAAgB,gBAAAhB,CAAA,EAAAC,CAAA,EAAAC,CAAA,YAAAD,CAAA,GAAAmB,cAAA,CAAAnB,CAAA,MAAAD,CAAA,GAAAG,MAAA,CAAAgB,cAAA,CAAAnB,CAAA,EAAAC,CAAA,IAAAoB,KAAA,EAAAnB,CAAA,EAAAO,UAAA,MAAAa,YAAA,MAAAC,QAAA,UAAAvB,CAAA,CAAAC,CAAA,IAAAC,CAAA,EAAAF,CAAA;AAAA,SAAAoB,eAAAlB,CAAA,QAAAsB,CAAA,GAAAC,YAAA,CAAAvB,CAAA,uCAAAsB,CAAA,GAAAA,CAAA,GAAAA,CAAA;AAAA,SAAAC,aAAAvB,CAAA,EAAAD,CAAA,2BAAAC,CAAA,KAAAA,CAAA,SAAAA,CAAA,MAAAF,CAAA,GAAAE,CAAA,CAAAwB,MAAA,CAAAC,WAAA,kBAAA3B,CAAA,QAAAwB,CAAA,GAAAxB,CAAA,CAAA4B,IAAA,CAAA1B,CAAA,EAAAD,CAAA,uCAAAuB,CAAA,SAAAA,CAAA,YAAAK,SAAA,yEAAA5B,CAAA,GAAA6B,MAAA,GAAAC,MAAA,EAAA7B,CAAA;AAoBhC,MAAM8B,WAAW,SAASC,oBAAS,CAAC;EAMzCC,WAAWA,CAACC,KAAuB,EAAE;IACnC,KAAK,CAAC,CAAC;IAACnB,eAAA;IAAAA,eAAA;IAAAA,eAAA;IAAAA,eAAA;IACR,IAAI,CAACoB,IAAI,GAAGD,KAAK,CAACC,IAAI;IACtB,IAAI,CAACC,KAAK,GAAGF,KAAK,CAACE,KAAK;IACxB,IAAI,CAACC,QAAQ,GAAGH,KAAK,CAACG,QAAQ;IAC9B,IAAI,CAACC,OAAO,GAAGJ,KAAK,CAACI,OAAO;EAC9B;EAEAC,EAAEA,CAAA,EAAG;IACH,OAAO,GAAG,IAAI,CAACF,QAAQ,IAAIN,WAAW,CAACI,IAAI,EAAE;EAC/C;EAEA,OAAOK,cAAcA,CAACC,UAAgB,EAAe;IACnD,OAAO,IAAIV,WAAW,CAAC;MACrBK,KAAK,EAAEK,UAAU,CAACL,KAAK;MACvBD,IAAI,EAAEM,UAAU,CAACN,IAAI;MACrBE,QAAQ,EAAEI,UAAU,CAACC,IAAI,CAAC,CAAC,CAACC,QAAQ,CAAC,CAAC;MACtCL,OAAO,EAAE,CAAC;IACZ,CAAC,CAAC;EACJ;EAEAM,QAAQA,CAAA,EAAwB;IAC9B,OAAO;MACLT,IAAI,EAAE,IAAI,CAACA,IAAI;MACfC,KAAK,EAAE,IAAI,CAACA,KAAK;MACjBC,QAAQ,EAAE,IAAI,CAACA,QAAQ;MACvBC,OAAO,EAAE,IAAI,CAACA;IAChB,CAAC;EACH;EAEAK,QAAQA,CAACE,MAAe,EAAU;IAChC,MAAMC,IAAI,GAAG,IAAAC,0BAAgB,EAACF,MAAM,CAAC;IACrC,OAAOG,IAAI,CAACC,SAAS,CAAC,IAAI,CAACL,QAAQ,CAAC,CAAC,EAAE,GAAGE,IAAI,CAAC;EACjD;EAEAI,QAAQA,CAACL,MAAM,EAAU;IACvB,OAAOM,MAAM,CAACC,IAAI,CAAC,IAAI,CAACT,QAAQ,CAACE,MAAM,CAAC,CAAC;EAC3C;EAEAQ,UAAUA,CAAA,EAAY;IACpB,OAAO,IAAI,CAACf,OAAO;EACrB;EAEA,MAAMgB,UAAUA,CAACC,OAAa,EAAEC,GAAY,EAAE;IAC5C,MAAMC,GAAQ,GAAG,MAAM,IAAAC,6BAAW,EAAC,CAAC;IACpC,IAAIF,GAAG,EAAEC,GAAG,CAACE,OAAO,GAAGH,GAAG;IAC1B,MAAMI,UAAU,GAAGL,OAAO,CAACM,cAAc,CAAC,CAAC,CAACC,aAAa,CAAC,CAAC;IAC3D,MAAMC,OAAO,GAAGR,OAAO,CAACK,UAAU,CAC/BtD,MAAM,CAAE0D,CAAC,IAAKA,CAAC,CAACC,SAAS,CAAC,CAC1BC,GAAG,CAAEF,CAAC,IAAKA,CAAC,CAACzB,EAAE,CAAC4B,aAAa,CAACH,CAAC,CAACI,IAAI,CAACzB,QAAQ,CAAC,CAAC,CAAC,CAACA,QAAQ,CAAC,CAAC,CAAC;IAC/D,IAAI,CAACL,OAAO,CAAC,IAAA+B,UAAE,EAAC,CAAC,CAAC,GAAA1D,aAAA;MAAK8C,GAAG;MAAEG;IAAU,GAAMG,OAAO,CAAClD,MAAM,IAAI;MAAEkD;IAAQ,CAAC,CAAG;EAC9E;EAEAO,KAAKA,CAACC,WAAwB,EAAE;IAC9B,IAAI,CAACjC,OAAO,GAAA3B,aAAA,CAAAA,aAAA,KAAQ,IAAI,CAAC2B,OAAO,GAAKiC,WAAW,CAACjC,OAAO,CAAE;EAC5D;EAEA,OAAOkC,MAAMA,CAACrC,IAAY,EAAEC,KAAa,EAAEC,QAAgB,EAAE;IAC3D,OAAO,IAAIN,WAAW,CAAC;MACrBI,IAAI;MACJC,KAAK;MACLC,QAAQ;MACRC,OAAO,EAAE,CAAC;IACZ,CAAC,CAAC;EACJ;EAEA,OAAOmC,KAAKA,CAACC,QAAgB,EAAe;IAC1C,MAAMC,MAAM,GAAG3B,IAAI,CAACyB,KAAK,CAACC,QAAQ,CAAC;IACnC,MAAMxC,KAAuB,GAAG;MAC9BC,IAAI,EAAEwC,MAAM,CAACxC,IAAI;MACjBC,KAAK,EAAEuC,MAAM,CAACvC,KAAK;MACnBC,QAAQ,EAAEsC,MAAM,CAACtC,QAAQ;MACzBC,OAAO,EAAEqC,MAAM,CAACrC;IAClB,CAAC;IACD,OAAO,IAAIP,WAAW,CAACG,KAAK,CAAC;EAC/B;AACF;AAAC0C,OAAA,CAAA7C,WAAA,GAAAA,WAAA","ignoreList":[]}

package/dist/models/lane.d.ts

@@ -0,0 +1,124 @@
+import { ComponentID, ComponentIdList } from '@teambit/component-id';
+import { LaneId } from '@teambit/lane-id';
+import { Scope } from '@teambit/legacy.scope';
+import { BitObject, Ref, Repository } from '../objects';
+export type Log = {
+    date: string;
+    username?: string;
+    email?: string;
+    profileImage?: string;
+};
+export type LaneProps = {
+    name: string;
+    scope: string;
+    log: Log;
+    components?: LaneComponent[];
+    hash: string;
+    schema?: string;
+    readmeComponent?: LaneReadmeComponent;
+    forkedFrom?: LaneId;
+    updateDependents?: ComponentID[];
+    overrideUpdateDependents?: boolean;
+};
+export type LaneComponent = {
+    id: ComponentID;
+    head: Ref;
+    isDeleted?: boolean;
+};
+export type LaneReadmeComponent = {
+    id: ComponentID;
+    head: Ref | null;
+};
+export default class Lane extends BitObject {
+    name: string;
+    scope: string;
+    components: LaneComponent[];
+    log: Log;
+    schema: string;
+    readmeComponent?: LaneReadmeComponent;
+    forkedFrom?: LaneId;
+    _hash: string;
+    isNew: boolean;
+    hasChanged: boolean;
+    /**
+     * populated when a user clicks on "update" in the UI. it's a list of components that are dependents on the
+     * components in the lane. their dependencies are updated according to the lane.
+     * from the CLI perspective, it's added by "bit _snap" and merged by "bit _merge-lane".
+     * otherwise, the user is not aware of it. it's not imported to the workspace and the objects are not fetched.
+     */
+    updateDependents?: ComponentID[];
+    private overrideUpdateDependents?;
+    constructor(props: LaneProps);
+    id(): string;
+    hash(): Ref;
+    changeName(name: string): void;
+    changeScope(scope: string): void;
+    refs(): Ref[];
+    validateBeforePersisting(str: string): void;
+    toObject(): import("lodash").Dictionary<string | boolean | string[] | {
+        scope: string;
+        name: string;
+    } | Log | {
+        isDeleted?: true | undefined;
+        id: {
+            scope: string;
+            name: string;
+        };
+        head: string;
+    }[] | {
+        id: {
+            scope: string;
+            name: string;
+        };
+        head: string | null;
+    } | undefined>;
+    static from(props: LaneProps): Lane;
+    static create(name: string, scope: string, forkedFrom?: LaneId, bitCloudUser?: {
+        username?: string;
+        email?: string;
+        profileImage?: string;
+    }): Lane;
+    static parse(contents: string, hash: string): Lane;
+    toBuffer(pretty?: boolean): Buffer;
+    addComponent(component: LaneComponent): void;
+    removeComponentFromUpdateDependentsIfExist(componentId: ComponentID): void;
+    addComponentToUpdateDependents(componentId: ComponentID): void;
+    removeAllUpdateDependents(): void;
+    shouldOverrideUpdateDependents(): boolean | undefined;
+    /**
+     * !!! important !!!
+     * this should get called only on a "temp lane", such as running "bit _snap", which the scope gets destroys after the
+     * command is done. when _scope exports the lane, this "overrideUpdateDependents" is not saved to the remote-scope.
+     *
+     * on a user local lane object, this prop should never be true. otherwise, it'll override the remote-scope data.
+     */
+    setOverrideUpdateDependents(overrideUpdateDependents: boolean): void;
+    removeComponent(id: ComponentID): boolean;
+    getComponent(id: ComponentID): LaneComponent | undefined;
+    getComponentHead(bitId: ComponentID): Ref | null;
+    setLaneComponents(laneComponents: LaneComponent[]): void;
+    setReadmeComponent(id?: ComponentID): void;
+    isFullyMerged(scope: Scope): Promise<boolean>;
+    getMergedAndUnmergedIds(scope: Scope): Promise<{
+        merged: ComponentID[];
+        unmerged: ComponentID[];
+    }>;
+    /**
+     * @deprecated use toComponentIds instead
+     */
+    toBitIds(): ComponentIdList;
+    toComponentIds(): ComponentIdList;
+    toComponentIdsIncludeUpdateDependents(): ComponentIdList;
+    toLaneId(): LaneId;
+    collectObjectsById(repo: Repository): Promise<Array<{
+        id: ComponentID;
+        objects: BitObject[];
+    }>>;
+    includeDeletedData(): boolean;
+    setSchemaToSupportDeletedData(): void;
+    setSchemaToNotSupportDeletedData(): void;
+    getCompHeadIncludeUpdateDependents(componentId: ComponentID): Ref | undefined;
+    validate(): void;
+    isEqual(lane: Lane): boolean;
+    clone(): Lane;
+}

package/dist/models/lane.js

@@ -0,0 +1,463 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _uuid() {
+  const data = require("uuid");
+  _uuid = function () {
+    return data;
+  };
+  return data;
+}
+function _semver() {
+  const data = require("semver");
+  _semver = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _bitError() {
+  const data = require("@teambit/bit-error");
+  _bitError = function () {
+    return data;
+  };
+  return data;
+}
+function _componentId() {
+  const data = require("@teambit/component-id");
+  _componentId = function () {
+    return data;
+  };
+  return data;
+}
+function _componentVersion() {
+  const data = require("@teambit/component-version");
+  _componentVersion = function () {
+    return data;
+  };
+  return data;
+}
+function _laneId() {
+  const data = require("@teambit/lane-id");
+  _laneId = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy() {
+  const data = require("@teambit/legacy.constants");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _legacyCli() {
+  const data = require("@teambit/legacy.cli.error");
+  _legacyCli = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy2() {
+  const data = require("@teambit/legacy.logger");
+  _legacy2 = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy3() {
+  const data = require("@teambit/legacy.utils");
+  _legacy3 = function () {
+    return data;
+  };
+  return data;
+}
+function _toolboxCrypto() {
+  const data = require("@teambit/toolbox.crypto.sha1");
+  _toolboxCrypto = function () {
+    return data;
+  };
+  return data;
+}
+function _component() {
+  const data = require("@teambit/component.snap-distance");
+  _component = function () {
+    return data;
+  };
+  return data;
+}
+function _objects() {
+  const data = require("../objects");
+  _objects = function () {
+    return data;
+  };
+  return data;
+}
+function globalConfig() {
+  const data = _interopRequireWildcard(require("@teambit/legacy.global-config"));
+  globalConfig = function () {
+    return data;
+  };
+  return data;
+}
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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 OLD_LANE_SCHEMA = '0.0.0';
+const SCHEMA_INCLUDING_DELETED_COMPONENTS_DATA = '1.0.0';
+const CURRENT_LANE_SCHEMA = SCHEMA_INCLUDING_DELETED_COMPONENTS_DATA;
+class Lane extends _objects().BitObject {
+  constructor(props) {
+    super();
+    _defineProperty(this, "name", void 0);
+    _defineProperty(this, "scope", void 0);
+    _defineProperty(this, "components", void 0);
+    _defineProperty(this, "log", void 0);
+    _defineProperty(this, "schema", void 0);
+    _defineProperty(this, "readmeComponent", void 0);
+    _defineProperty(this, "forkedFrom", void 0);
+    _defineProperty(this, "_hash", void 0);
+    // reason for the underscore prefix is that we already have hash as a method
+    _defineProperty(this, "isNew", false);
+    // doesn't get saved in the object. only needed for in-memory instance
+    _defineProperty(this, "hasChanged", false);
+    // doesn't get saved in the object. only needed for in-memory instance
+    /**
+     * populated when a user clicks on "update" in the UI. it's a list of components that are dependents on the
+     * components in the lane. their dependencies are updated according to the lane.
+     * from the CLI perspective, it's added by "bit _snap" and merged by "bit _merge-lane".
+     * otherwise, the user is not aware of it. it's not imported to the workspace and the objects are not fetched.
+     */
+    _defineProperty(this, "updateDependents", void 0);
+    _defineProperty(this, "overrideUpdateDependents", void 0);
+    if (!props.name) throw new TypeError('Lane constructor expects to get a name parameter');
+    this.name = props.name;
+    this.scope = props.scope;
+    this.components = props.components || [];
+    this.log = props.log || {
+      date: Date.now().toString()
+    };
+    this._hash = props.hash;
+    this.readmeComponent = props.readmeComponent;
+    this.forkedFrom = props.forkedFrom;
+    this.schema = props.schema || OLD_LANE_SCHEMA;
+    this.updateDependents = props.updateDependents;
+    this.overrideUpdateDependents = props.overrideUpdateDependents;
+  }
+  id() {
+    return this.scope + _laneId().LANE_REMOTE_DELIMITER + this.name;
+  }
+  hash() {
+    if (!this._hash) {
+      throw new Error('hash is missing from a Lane object');
+    }
+    return new (_objects().Ref)(this._hash);
+  }
+  changeName(name) {
+    this.name = name;
+    this.hasChanged = true;
+  }
+  changeScope(scope) {
+    this.scope = scope;
+    this.hasChanged = true;
+  }
+  refs() {
+    return this.components.map(c => c.head);
+  }
+  validateBeforePersisting(str) {
+    _legacy2().logger.debug(`validating lane object: ${this.hash().toString()} ${this.id()}`);
+    const lane = Lane.parse(str, this.hash().toString());
+    lane.validate();
+  }
+  toObject() {
+    const obj = (0, _lodash().pickBy)({
+      name: this.name,
+      scope: this.scope,
+      components: this.components.map(component => _objectSpread({
+        id: {
+          scope: component.id.scope,
+          name: component.id.fullName
+        },
+        head: component.head.toString()
+      }, component.isDeleted && {
+        isDeleted: component.isDeleted
+      })),
+      log: this.log,
+      readmeComponent: this.readmeComponent && {
+        id: {
+          scope: this.readmeComponent.id.scope,
+          name: this.readmeComponent.id.fullName
+        },
+        head: this.readmeComponent.head?.toString() ?? null
+      },
+      forkedFrom: this.forkedFrom && this.forkedFrom.toObject(),
+      schema: this.schema,
+      updateDependents: this.updateDependents?.map(c => c.toString()),
+      overrideUpdateDependents: this.overrideUpdateDependents
+    }, val => !!val);
+    return obj;
+  }
+  static from(props) {
+    return new Lane(props);
+  }
+  static create(name, scope, forkedFrom, bitCloudUser) {
+    const log = {
+      date: Date.now().toString(),
+      username: bitCloudUser?.username || globalConfig().getSync(_legacy().CFG_USER_NAME_KEY),
+      email: bitCloudUser?.email || globalConfig().getSync(_legacy().CFG_USER_EMAIL_KEY),
+      profileImage: bitCloudUser?.profileImage
+    };
+    const lane = new Lane({
+      name,
+      scope,
+      hash: (0, _toolboxCrypto().sha1)((0, _uuid().v4)()),
+      log,
+      forkedFrom,
+      schema: CURRENT_LANE_SCHEMA
+    });
+    lane.isNew = true;
+    lane.hasChanged = true;
+    return lane;
+  }
+  static parse(contents, hash) {
+    const laneObject = JSON.parse(contents);
+    return Lane.from({
+      name: laneObject.name,
+      scope: laneObject.scope,
+      log: laneObject.log,
+      components: laneObject.components.map(component => ({
+        id: _componentId().ComponentID.fromObject({
+          scope: component.id.scope,
+          name: component.id.name
+        }),
+        head: new (_objects().Ref)(component.head),
+        isDeleted: component.isDeleted
+      })),
+      readmeComponent: laneObject.readmeComponent && {
+        id: _componentId().ComponentID.fromObject({
+          scope: laneObject.readmeComponent.id.scope,
+          name: laneObject.readmeComponent.id.name
+        }),
+        head: laneObject.readmeComponent.head && new (_objects().Ref)(laneObject.readmeComponent.head)
+      },
+      forkedFrom: laneObject.forkedFrom && _laneId().LaneId.from(laneObject.forkedFrom.name, laneObject.forkedFrom.scope),
+      updateDependents: laneObject.updateDependents?.map(c => _componentId().ComponentID.fromString(c)),
+      overrideUpdateDependents: laneObject.overrideUpdateDependents,
+      hash: laneObject.hash || hash,
+      schema: laneObject.schema
+    });
+  }
+  toBuffer(pretty) {
+    const args = (0, _legacy3().getStringifyArgs)(pretty);
+    const obj = this.toObject();
+    const str = JSON.stringify(obj, ...args);
+    if (this.validateBeforePersist) this.validateBeforePersisting(str);
+    return Buffer.from(str);
+  }
+  addComponent(component) {
+    const existsComponent = this.getComponent(component.id);
+    if (existsComponent) {
+      if (!existsComponent.head.isEqual(component.head)) this.hasChanged = true;
+      existsComponent.id = component.id;
+      existsComponent.head = component.head;
+      existsComponent.isDeleted = component.isDeleted;
+    } else {
+      _legacy2().logger.debug(`Lane.addComponent, adding component ${component.id.toString()} to lane ${this.id()}`);
+      this.components.push(component);
+      this.hasChanged = true;
+    }
+  }
+  removeComponentFromUpdateDependentsIfExist(componentId) {
+    const updateDependentsList = _componentId().ComponentIdList.fromArray(this.updateDependents || []);
+    const exist = updateDependentsList.searchWithoutVersion(componentId);
+    if (!exist) return;
+    this.updateDependents = updateDependentsList.removeIfExist(exist);
+    if (!this.updateDependents.length) this.updateDependents = undefined;
+    this.hasChanged = true;
+  }
+  addComponentToUpdateDependents(componentId) {
+    this.removeComponentFromUpdateDependentsIfExist(componentId);
+    (this.updateDependents ||= []).push(componentId);
+    this.hasChanged = true;
+  }
+  removeAllUpdateDependents() {
+    if (this.updateDependents?.length) return;
+    this.updateDependents = undefined;
+    this.hasChanged = true;
+  }
+  shouldOverrideUpdateDependents() {
+    return this.overrideUpdateDependents;
+  }
+  /**
+   * !!! important !!!
+   * this should get called only on a "temp lane", such as running "bit _snap", which the scope gets destroys after the
+   * command is done. when _scope exports the lane, this "overrideUpdateDependents" is not saved to the remote-scope.
+   *
+   * on a user local lane object, this prop should never be true. otherwise, it'll override the remote-scope data.
+   */
+  setOverrideUpdateDependents(overrideUpdateDependents) {
+    this.overrideUpdateDependents = overrideUpdateDependents;
+    this.hasChanged = true;
+  }
+  removeComponent(id) {
+    const existsComponent = this.getComponent(id);
+    if (!existsComponent) return false;
+    this.components = this.components.filter(c => !c.id.isEqualWithoutVersion(id));
+    this.hasChanged = true;
+    return true;
+  }
+  getComponent(id) {
+    return this.components.find(c => c.id.isEqualWithoutVersion(id));
+  }
+  getComponentHead(bitId) {
+    const found = this.components.find(c => c.id.isEqual(bitId));
+    if (found) return found.head;
+    return null;
+  }
+  setLaneComponents(laneComponents) {
+    // this gets called when adding lane-components from other lanes/remotes, so it's better to
+    // clone the objects to not change the original data.
+    this.components = laneComponents.map(c => ({
+      id: c.id.clone(),
+      head: c.head.clone()
+    }));
+    this.hasChanged = true;
+  }
+  setReadmeComponent(id) {
+    const previousReadme = this.readmeComponent;
+    if (!id) {
+      this.readmeComponent = undefined;
+      if (previousReadme) this.hasChanged = true;
+      return;
+    }
+    const readmeComponent = this.getComponent(id);
+    if (!readmeComponent) {
+      this.readmeComponent = {
+        id,
+        head: null
+      };
+    } else {
+      this.readmeComponent = readmeComponent;
+    }
+    if (!previousReadme || !previousReadme.id.isEqual(id) || previousReadme.head?.toString() !== this.readmeComponent.head?.toString()) {
+      this.hasChanged = true;
+    }
+  }
+  async isFullyMerged(scope) {
+    const {
+      unmerged
+    } = await this.getMergedAndUnmergedIds(scope);
+    return unmerged.length === 0;
+  }
+  async getMergedAndUnmergedIds(scope) {
+    const merged = [];
+    const unmerged = [];
+    await Promise.all(this.components.map(async component => {
+      const modelComponent = await scope.getModelComponentIfExist(component.id);
+      if (!modelComponent) {
+        unmerged.push(component.id);
+        return;
+      }
+      const startTraverseFrom = modelComponent.getHead() || null; // it's important to have it as null and not as undefined, see hasVersionByRef
+      const headExist = await (0, _component().hasVersionByRef)(modelComponent, component.head, scope.objects, startTraverseFrom);
+      if (headExist) merged.push(component.id);else unmerged.push(component.id);
+    }));
+    return {
+      merged,
+      unmerged
+    };
+  }
+  /**
+   * @deprecated use toComponentIds instead
+   */
+  toBitIds() {
+    return this.toComponentIds();
+  }
+  toComponentIds() {
+    return _componentId().ComponentIdList.fromArray(this.components.map(c => c.id.changeVersion(c.head.toString())));
+  }
+  toComponentIdsIncludeUpdateDependents() {
+    return _componentId().ComponentIdList.fromArray(this.toComponentIds().concat(this.updateDependents || []));
+  }
+  toLaneId() {
+    return new (_laneId().LaneId)({
+      scope: this.scope,
+      name: this.name
+    });
+  }
+  collectObjectsById(repo) {
+    return Promise.all(this.components.map(async component => {
+      const headVersion = await component.head.load(repo);
+      const objects = [headVersion, ...headVersion.collect(repo)];
+      return {
+        id: component.id,
+        objects
+      };
+    }));
+  }
+  includeDeletedData() {
+    return (0, _semver().gte)(this.schema, SCHEMA_INCLUDING_DELETED_COMPONENTS_DATA);
+  }
+  setSchemaToSupportDeletedData() {
+    this.schema = SCHEMA_INCLUDING_DELETED_COMPONENTS_DATA;
+    this.hasChanged = true;
+  }
+  setSchemaToNotSupportDeletedData() {
+    this.schema = OLD_LANE_SCHEMA;
+    this.hasChanged = true;
+  }
+  getCompHeadIncludeUpdateDependents(componentId) {
+    const comp = this.getComponent(componentId);
+    if (comp) return comp.head;
+    const fromUpdateDependents = this.updateDependents?.find(c => c.isEqualWithoutVersion(componentId));
+    if (fromUpdateDependents) return _objects().Ref.from(fromUpdateDependents.version);
+    return undefined;
+  }
+  validate() {
+    const message = `unable to save Lane object "${this.id()}"`;
+    const bitIds = this.toComponentIds();
+    this.components.forEach(component => {
+      if (bitIds.filterWithoutVersion(component.id).length > 1) {
+        throw new (_legacyCli().ValidationError)(`${message}, the following component is duplicated "${component.id.fullName}"`);
+      }
+      if (!(0, _componentVersion().isSnap)(component.head.hash)) {
+        throw new (_legacyCli().ValidationError)(`${message}, lane component ${component.id.toStringWithoutVersion()} head should be a hash, got ${component.head.hash}`);
+      }
+    });
+    if (this.name === _laneId().DEFAULT_LANE) {
+      throw new (_bitError().BitError)(`${message}, this name is reserved as the default lane`);
+    }
+    if (this.name === _legacy().PREVIOUS_DEFAULT_LANE) {
+      throw new (_bitError().BitError)(`${message}, this name is reserved as the old default lane`);
+    }
+  }
+  isEqual(lane) {
+    if (this.id() !== lane.id()) return false;
+    const thisComponents = this.toComponentIds().toStringArray().sort();
+    const otherComponents = lane.toComponentIds().toStringArray().sort();
+    return (0, _lodash().isEqual)(thisComponents, otherComponents);
+  }
+  clone() {
+    return new Lane(_objectSpread(_objectSpread({}, this), {}, {
+      hash: this._hash,
+      overrideUpdateDependents: this.overrideUpdateDependents,
+      components: (0, _lodash().cloneDeep)(this.components)
+    }));
+  }
+}
+exports.default = Lane;
+
+//# sourceMappingURL=lane.js.map