@teambit/objects 0.0.0-00042bc99514ea12d897f81bcd0181e2b034c615

package/dist/models/lane.d.ts

@@ -0,0 +1,128 @@
+import { ComponentID, ComponentIdList } from '@teambit/component-id';
+import { LaneId } from '@teambit/lane-id';
+import type { Scope } from '@teambit/legacy.scope';
+import type { Repository } from '../objects';
+import { BitObject, Ref } 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;
+    /**
+     * components that are dependents of components in the lane and need to be re-snapped against the
+     * lane's heads. populated by the bare-scope cascade producer (UI "snap updates" / `bit _snap`)
+     * and by `bit _merge-lane`. these entries are part of the lane's graph (Ripple CI builds them,
+     * merge engine refreshes them) but are intentionally hidden from workspace-facing flows
+     * (`bit status`, `bit compile`, `bit install`, the bitmap).
+     */
+    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;
+    } | {
+        isDeleted?: true | undefined;
+        id: {
+            scope: string;
+            name: string;
+        };
+        head: string;
+    }[] | Log | {
+        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<ArrayBuffer>;
+    addComponent(component: LaneComponent): void;
+    findUpdateDependent(componentId: ComponentID): ComponentID | undefined;
+    getUpdateDependentAsLaneComponent(componentId: ComponentID): LaneComponent | undefined;
+    removeComponentFromUpdateDependentsIfExist(componentId: ComponentID): void;
+    addComponentToUpdateDependents(componentId: ComponentID): void;
+    removeAllUpdateDependents(): void;
+    /**
+     * Signals an explicit `_snap --update-dependents` insertion. On export, the receiving scope
+     * gates its "add this new hidden entry" branch on this flag so a stale workspace lane can't
+     * resurrect entries the Cloud UI dropped. Workspace cascades — which only update existing
+     * entries — deliberately do NOT set the flag. The field is also serialized by `Lane.toObject`
+     * for older remotes that gate their pre-diverge-check override branch on it.
+     */
+    setOverrideUpdateDependents(overrideUpdateDependents: boolean): void;
+    shouldOverrideUpdateDependents(): boolean;
+    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,485 @@
+"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 _configStore() {
+  const data = require("@teambit/config-store");
+  _configStore = function () {
+    return data;
+  };
+  return data;
+}
+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
+    /**
+     * components that are dependents of components in the lane and need to be re-snapped against the
+     * lane's heads. populated by the bare-scope cascade producer (UI "snap updates" / `bit _snap`)
+     * and by `bit _merge-lane`. these entries are part of the lane's graph (Ripple CI builds them,
+     * merge engine refreshes them) but are intentionally hidden from workspace-facing flows
+     * (`bit status`, `bit compile`, `bit install`, the bitmap).
+     */
+    _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 || (0, _configStore().getConfig)(_legacy().CFG_USER_NAME_KEY),
+      email: bitCloudUser?.email || (0, _configStore().getConfig)(_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) || Boolean(existsComponent.isDeleted) !== Boolean(component.isDeleted)) {
+        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;
+    }
+  }
+  findUpdateDependent(componentId) {
+    return this.updateDependents?.find(c => c.isEqualWithoutVersion(componentId));
+  }
+  getUpdateDependentAsLaneComponent(componentId) {
+    const found = this.findUpdateDependent(componentId);
+    if (!found?.version) return undefined;
+    return {
+      id: found.changeVersion(undefined),
+      head: _objects().Ref.from(found.version)
+    };
+  }
+  removeComponentFromUpdateDependentsIfExist(componentId) {
+    if (!this.findUpdateDependent(componentId)) return;
+    this.updateDependents = this.updateDependents?.filter(c => !c.isEqualWithoutVersion(componentId));
+    if (!this.updateDependents?.length) this.updateDependents = undefined;
+    this.hasChanged = true;
+  }
+  addComponentToUpdateDependents(componentId) {
+    if (!componentId.hasVersion()) {
+      throw new (_legacyCli().ValidationError)(`Lane.addComponentToUpdateDependents: ${componentId.toString()} is missing a version`);
+    }
+    this.removeComponentFromUpdateDependentsIfExist(componentId);
+    (this.updateDependents ||= []).push(componentId);
+    this.hasChanged = true;
+  }
+  removeAllUpdateDependents() {
+    if (!this.updateDependents?.length) return;
+    this.updateDependents = undefined;
+    this.hasChanged = true;
+  }
+  /**
+   * Signals an explicit `_snap --update-dependents` insertion. On export, the receiving scope
+   * gates its "add this new hidden entry" branch on this flag so a stale workspace lane can't
+   * resurrect entries the Cloud UI dropped. Workspace cascades — which only update existing
+   * entries — deliberately do NOT set the flag. The field is also serialized by `Lane.toObject`
+   * for older remotes that gate their pre-diverge-check override branch on it.
+   */
+  setOverrideUpdateDependents(overrideUpdateDependents) {
+    this.overrideUpdateDependents = overrideUpdateDependents;
+    this.hasChanged = true;
+  }
+  shouldOverrideUpdateDependents() {
+    return Boolean(this.overrideUpdateDependents);
+  }
+  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 => _objectSpread({
+      id: c.id.clone(),
+      head: c.head.clone()
+    }, c.isDeleted && {
+      isDeleted: c.isDeleted
+    }));
+    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;
+    return this.getUpdateDependentAsLaneComponent(componentId)?.head;
+  }
+  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;
+    // include isDeleted in equality so a soft-delete flip with the same head still counts as a
+    // state change — `Lane.isEqual` is used by importers to decide whether to write a
+    // LaneHistory entry.
+    const normalize = l => l.components.map(c => ({
+      id: c.id.toStringWithoutVersion(),
+      head: c.head.toString(),
+      isDeleted: Boolean(c.isDeleted)
+    })).sort((a, b) => `${a.id}@${a.head}:${a.isDeleted ? 1 : 0}`.localeCompare(`${b.id}@${b.head}:${b.isDeleted ? 1 : 0}`));
+    const thisUpdDeps = (this.updateDependents || []).map(c => c.toString()).sort();
+    const otherUpdDeps = (lane.updateDependents || []).map(c => c.toString()).sort();
+    return (0, _lodash().isEqual)(normalize(this), normalize(lane)) && (0, _lodash().isEqual)(thisUpdDeps, otherUpdDeps);
+  }
+  clone() {
+    return new Lane(_objectSpread(_objectSpread({}, this), {}, {
+      hash: this._hash,
+      overrideUpdateDependents: this.overrideUpdateDependents,
+      components: (0, _lodash().cloneDeep)(this.components),
+      updateDependents: this.updateDependents ? (0, _lodash().cloneDeep)(this.updateDependents) : undefined
+    }));
+  }
+}
+exports.default = Lane;
+
+//# sourceMappingURL=lane.js.map