@teambit/objects 0.0.19

package/dist/objects/bit-object-list.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_models","data","require","BitObjectList","constructor","objects","getComponents","filter","object","ModelComponent","getVersions","Version","getLanes","Lane","getVersionHistories","VersionHistory","getLaneHistories","LaneHistory","getAll","excludeTypes","types","includes","getType","getExportMetadata","find","ExportMetadata","getObjectsRequireMerge","typeRequireMerge","objectTypesRequireMerge","some","ObjClass","getObjectsNotRequireMerge","every","exports"],"sources":["bit-object-list.ts"],"sourcesContent":["import BitObject from './object';\nimport { ExportMetadata, Lane, LaneHistory, ModelComponent, Version, VersionHistory } from '../models';\n\nexport class BitObjectList {\n  constructor(private objects: BitObject[]) {}\n\n  getComponents(): ModelComponent[] {\n    return this.objects.filter((object) => object instanceof ModelComponent) as ModelComponent[];\n  }\n\n  getVersions(): Version[] {\n    return this.objects.filter((object) => object instanceof Version) as Version[];\n  }\n\n  getLanes(): Lane[] {\n    return this.objects.filter((object) => object instanceof Lane) as Lane[];\n  }\n\n  getVersionHistories(): VersionHistory[] {\n    return this.objects.filter((object) => object instanceof VersionHistory) as VersionHistory[];\n  }\n\n  getLaneHistories(): LaneHistory[] {\n    return this.objects.filter((object) => object instanceof LaneHistory) as LaneHistory[];\n  }\n\n  getAll(): BitObject[] {\n    return this.objects;\n  }\n\n  excludeTypes(types: string[]): BitObject[] {\n    return this.objects.filter((object) => !types.includes(object.getType()));\n  }\n\n  getExportMetadata(): ExportMetadata | undefined {\n    return this.objects.find((object) => object instanceof ExportMetadata) as ExportMetadata | undefined;\n  }\n\n  /**\n   * object that needs merge operation before saving them into the scope, such as ModelComponent\n   */\n  getObjectsRequireMerge() {\n    const typeRequireMerge = this.objectTypesRequireMerge();\n    return this.objects.filter((object) => typeRequireMerge.some((ObjClass) => object instanceof ObjClass));\n  }\n\n  /**\n   * object that don't need merge operation and can be saved immediately into the scope.\n   * such as Source or Version\n   */\n  getObjectsNotRequireMerge() {\n    const typeRequireMerge = this.objectTypesRequireMerge();\n    return this.objects.filter((object) => typeRequireMerge.every((ObjClass) => !(object instanceof ObjClass)));\n  }\n\n  private objectTypesRequireMerge() {\n    return [ModelComponent, Lane, VersionHistory, LaneHistory];\n  }\n}\n"],"mappings":";;;;;;AACA,SAAAA,QAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,OAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEO,MAAME,aAAa,CAAC;EACzBC,WAAWA,CAASC,OAAoB,EAAE;IAAA,KAAtBA,OAAoB,GAApBA,OAAoB;EAAG;EAE3CC,aAAaA,CAAA,EAAqB;IAChC,OAAO,IAAI,CAACD,OAAO,CAACE,MAAM,CAAEC,MAAM,IAAKA,MAAM,YAAYC,wBAAc,CAAC;EAC1E;EAEAC,WAAWA,CAAA,EAAc;IACvB,OAAO,IAAI,CAACL,OAAO,CAACE,MAAM,CAAEC,MAAM,IAAKA,MAAM,YAAYG,iBAAO,CAAC;EACnE;EAEAC,QAAQA,CAAA,EAAW;IACjB,OAAO,IAAI,CAACP,OAAO,CAACE,MAAM,CAAEC,MAAM,IAAKA,MAAM,YAAYK,cAAI,CAAC;EAChE;EAEAC,mBAAmBA,CAAA,EAAqB;IACtC,OAAO,IAAI,CAACT,OAAO,CAACE,MAAM,CAAEC,MAAM,IAAKA,MAAM,YAAYO,wBAAc,CAAC;EAC1E;EAEAC,gBAAgBA,CAAA,EAAkB;IAChC,OAAO,IAAI,CAACX,OAAO,CAACE,MAAM,CAAEC,MAAM,IAAKA,MAAM,YAAYS,qBAAW,CAAC;EACvE;EAEAC,MAAMA,CAAA,EAAgB;IACpB,OAAO,IAAI,CAACb,OAAO;EACrB;EAEAc,YAAYA,CAACC,KAAe,EAAe;IACzC,OAAO,IAAI,CAACf,OAAO,CAACE,MAAM,CAAEC,MAAM,IAAK,CAACY,KAAK,CAACC,QAAQ,CAACb,MAAM,CAACc,OAAO,CAAC,CAAC,CAAC,CAAC;EAC3E;EAEAC,iBAAiBA,CAAA,EAA+B;IAC9C,OAAO,IAAI,CAAClB,OAAO,CAACmB,IAAI,CAAEhB,MAAM,IAAKA,MAAM,YAAYiB,wBAAc,CAAC;EACxE;;EAEA;AACF;AACA;EACEC,sBAAsBA,CAAA,EAAG;IACvB,MAAMC,gBAAgB,GAAG,IAAI,CAACC,uBAAuB,CAAC,CAAC;IACvD,OAAO,IAAI,CAACvB,OAAO,CAACE,MAAM,CAAEC,MAAM,IAAKmB,gBAAgB,CAACE,IAAI,CAAEC,QAAQ,IAAKtB,MAAM,YAAYsB,QAAQ,CAAC,CAAC;EACzG;;EAEA;AACF;AACA;AACA;EACEC,yBAAyBA,CAAA,EAAG;IAC1B,MAAMJ,gBAAgB,GAAG,IAAI,CAACC,uBAAuB,CAAC,CAAC;IACvD,OAAO,IAAI,CAACvB,OAAO,CAACE,MAAM,CAAEC,MAAM,IAAKmB,gBAAgB,CAACK,KAAK,CAAEF,QAAQ,IAAK,EAAEtB,MAAM,YAAYsB,QAAQ,CAAC,CAAC,CAAC;EAC7G;EAEQF,uBAAuBA,CAAA,EAAG;IAChC,OAAO,CAACnB,wBAAc,EAAEI,cAAI,EAAEE,wBAAc,EAAEE,qBAAW,CAAC;EAC5D;AACF;AAACgB,OAAA,CAAA9B,aAAA,GAAAA,aAAA","ignoreList":[]}

package/dist/objects/index.d.ts

@@ -0,0 +1,5 @@
+import BitObject from './object';
+import BitRawObject from './raw-object';
+import Ref from './ref';
+import Repository from './repository';
+export { BitObject, BitRawObject, Ref, Repository };

package/dist/objects/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "BitObject", {
+  enumerable: true,
+  get: function () {
+    return _object().default;
+  }
+});
+Object.defineProperty(exports, "BitRawObject", {
+  enumerable: true,
+  get: function () {
+    return _rawObject().default;
+  }
+});
+Object.defineProperty(exports, "Ref", {
+  enumerable: true,
+  get: function () {
+    return _ref().default;
+  }
+});
+Object.defineProperty(exports, "Repository", {
+  enumerable: true,
+  get: function () {
+    return _repository().default;
+  }
+});
+function _object() {
+  const data = _interopRequireDefault(require("./object"));
+  _object = function () {
+    return data;
+  };
+  return data;
+}
+function _rawObject() {
+  const data = _interopRequireDefault(require("./raw-object"));
+  _rawObject = function () {
+    return data;
+  };
+  return data;
+}
+function _ref() {
+  const data = _interopRequireDefault(require("./ref"));
+  _ref = function () {
+    return data;
+  };
+  return data;
+}
+function _repository() {
+  const data = _interopRequireDefault(require("./repository"));
+  _repository = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+
+//# sourceMappingURL=index.js.map

package/dist/objects/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_object","data","_interopRequireDefault","require","_rawObject","_ref","_repository","e","__esModule","default"],"sources":["index.ts"],"sourcesContent":["import BitObject from './object';\nimport BitRawObject from './raw-object';\nimport Ref from './ref';\nimport Repository from './repository';\n\nexport { BitObject, BitRawObject, Ref, Repository };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAAA,QAAA;EAAA,MAAAC,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAH,OAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,WAAA;EAAA,MAAAH,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAC,UAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAI,KAAA;EAAA,MAAAJ,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAE,IAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAK,YAAA;EAAA,MAAAL,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAG,WAAA,YAAAA,CAAA;IAAA,OAAAL,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAsC,SAAAC,uBAAAK,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA","ignoreList":[]}

package/dist/objects/object-list-to-graph.d.ts

@@ -0,0 +1,13 @@
+import { Graph, Node, Edge } from '@teambit/graph.cleargraph';
+import { ComponentID } from '@teambit/component-id';
+import type { ObjectList } from './object-list';
+import { BitObjectList } from './bit-object-list';
+import { Dependency } from '@teambit/graph';
+type BitIdNode = Node<ComponentID>;
+type DependencyEdge = Edge<Dependency>;
+export declare class IdGraph extends Graph<ComponentID, Dependency> {
+    constructor(nodes?: BitIdNode[], edges?: DependencyEdge[]);
+}
+export declare function objectListToGraph(objectList: ObjectList): Promise<IdGraph>;
+export declare function bitObjectListToGraph(bitObjectsList: BitObjectList): Promise<IdGraph>;
+export {};

package/dist/objects/object-list-to-graph.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IdGraph = void 0;
+exports.bitObjectListToGraph = bitObjectListToGraph;
+exports.objectListToGraph = objectListToGraph;
+function _graph() {
+  const data = require("@teambit/graph.cleargraph");
+  _graph = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _component() {
+  const data = require("@teambit/component.snap-distance");
+  _component = function () {
+    return data;
+  };
+  return data;
+}
+function _graph2() {
+  const data = require("@teambit/graph");
+  _graph2 = function () {
+    return data;
+  };
+  return data;
+}
+class IdGraph extends _graph().Graph {
+  constructor(nodes = [], edges = []) {
+    super(nodes, edges);
+  }
+}
+exports.IdGraph = IdGraph;
+async function objectListToGraph(objectList) {
+  const bitObjectsList = await objectList.toBitObjects();
+  return bitObjectListToGraph(bitObjectsList);
+}
+async function bitObjectListToGraph(bitObjectsList) {
+  const exportMetadata = bitObjectsList.getExportMetadata();
+  const components = bitObjectsList.getComponents();
+  const versions = bitObjectsList.getVersions();
+  const nodes = [];
+  const edges = [];
+  await Promise.all(components.map(async component => {
+    const compFromMetadata = exportMetadata?.exportVersions.find(c => c.id.isEqualWithoutVersion(component.toComponentId()));
+    const startFrom = compFromMetadata?.head;
+    const versionsInfo = await (0, _component().getAllVersionsInfo)({
+      modelComponent: component,
+      versionObjects: versions,
+      startFrom,
+      throws: false
+    });
+    versionsInfo.forEach(versionInfo => {
+      const id = component.toComponentId().changeVersion(versionInfo.tag || versionInfo.ref.toString());
+      const idStr = id.toString();
+      nodes.push(new (_graph().Node)(idStr, id));
+      if (!versionInfo.version) {
+        return;
+      }
+      const {
+        dependencies,
+        devDependencies,
+        peerDependencies,
+        extensionDependencies
+      } = versionInfo.version.depsIdsGroupedByType;
+      const addDep = (depId, edge) => {
+        const depIdStr = depId.toString();
+        nodes.push(new (_graph().Node)(depIdStr, depId));
+        edges.push(new (_graph().Edge)(idStr, depIdStr, edge));
+      };
+      const runTime = new (_graph2().Dependency)('runtime');
+      const dev = new (_graph2().Dependency)('dev');
+      const peer = new (_graph2().Dependency)('peer');
+      dependencies.forEach(depId => addDep(depId, runTime));
+      [...devDependencies, ...extensionDependencies].forEach(depId => addDep(depId, dev));
+      peerDependencies.forEach(depId => addDep(depId, peer));
+    });
+  }));
+  const uniqNodes = (0, _lodash().uniqBy)(nodes, 'id');
+  const idGraph = new IdGraph(uniqNodes, edges);
+  return idGraph;
+}
+
+//# sourceMappingURL=object-list-to-graph.js.map

package/dist/objects/object-list-to-graph.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_graph","data","require","_lodash","_component","_graph2","IdGraph","Graph","constructor","nodes","edges","exports","objectListToGraph","objectList","bitObjectsList","toBitObjects","bitObjectListToGraph","exportMetadata","getExportMetadata","components","getComponents","versions","getVersions","Promise","all","map","component","compFromMetadata","exportVersions","find","c","id","isEqualWithoutVersion","toComponentId","startFrom","head","versionsInfo","getAllVersionsInfo","modelComponent","versionObjects","throws","forEach","versionInfo","changeVersion","tag","ref","toString","idStr","push","Node","version","dependencies","devDependencies","peerDependencies","extensionDependencies","depsIdsGroupedByType","addDep","depId","edge","depIdStr","Edge","runTime","Dependency","dev","peer","uniqNodes","uniqBy","idGraph"],"sources":["object-list-to-graph.ts"],"sourcesContent":["import { Graph, Node, Edge } from '@teambit/graph.cleargraph';\nimport { uniqBy } from 'lodash';\nimport { ComponentID } from '@teambit/component-id';\nimport type { ObjectList } from './object-list';\nimport { BitObjectList } from './bit-object-list';\nimport { getAllVersionsInfo } from '@teambit/component.snap-distance';\nimport { Dependency } from '@teambit/graph';\n\ntype BitIdNode = Node<ComponentID>;\ntype DependencyEdge = Edge<Dependency>;\n\nexport class IdGraph extends Graph<ComponentID, Dependency> {\n  constructor(nodes: BitIdNode[] = [], edges: DependencyEdge[] = []) {\n    super(nodes, edges);\n  }\n}\n\nexport async function objectListToGraph(objectList: ObjectList): Promise<IdGraph> {\n  const bitObjectsList = await objectList.toBitObjects();\n\n  return bitObjectListToGraph(bitObjectsList);\n}\n\nexport async function bitObjectListToGraph(bitObjectsList: BitObjectList): Promise<IdGraph> {\n  const exportMetadata = bitObjectsList.getExportMetadata();\n  const components = bitObjectsList.getComponents();\n  const versions = bitObjectsList.getVersions();\n  const nodes: BitIdNode[] = [];\n  const edges: DependencyEdge[] = [];\n  await Promise.all(\n    components.map(async (component) => {\n      const compFromMetadata = exportMetadata?.exportVersions.find((c) =>\n        c.id.isEqualWithoutVersion(component.toComponentId())\n      );\n      const startFrom = compFromMetadata?.head;\n      const versionsInfo = await getAllVersionsInfo({\n        modelComponent: component,\n        versionObjects: versions,\n        startFrom,\n        throws: false,\n      });\n      versionsInfo.forEach((versionInfo) => {\n        const id = component.toComponentId().changeVersion(versionInfo.tag || versionInfo.ref.toString());\n        const idStr = id.toString();\n        nodes.push(new Node(idStr, id));\n        if (!versionInfo.version) {\n          return;\n        }\n        const { dependencies, devDependencies, peerDependencies, extensionDependencies } =\n          versionInfo.version.depsIdsGroupedByType;\n        const addDep = (depId: ComponentID, edge: Dependency) => {\n          const depIdStr = depId.toString();\n          nodes.push(new Node(depIdStr, depId));\n          edges.push(new Edge(idStr, depIdStr, edge));\n        };\n        const runTime = new Dependency('runtime');\n        const dev = new Dependency('dev');\n        const peer = new Dependency('peer');\n        dependencies.forEach((depId) => addDep(depId, runTime));\n        [...devDependencies, ...extensionDependencies].forEach((depId) => addDep(depId, dev));\n        peerDependencies.forEach((depId) => addDep(depId, peer));\n      });\n    })\n  );\n  const uniqNodes = uniqBy(nodes, 'id');\n  const idGraph = new IdGraph(uniqNodes, edges);\n\n  return idGraph;\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/objects/object-list.d.ts

@@ -0,0 +1,52 @@
+import { Readable } from 'stream';
+import BitObject from './object';
+import { BitObjectList } from './bit-object-list';
+import Ref from './ref';
+export type ObjectItem = {
+    ref: Ref;
+    buffer: Buffer;
+    type?: string;
+    scope?: string;
+};
+export declare const FETCH_FORMAT_OBJECT_LIST = "ObjectList";
+/**
+ * Stream.Readable that operates with objectMode, while each 'data' event emits one ObjectItem object.
+ */
+export type ObjectItemsStream = Readable;
+export declare class ObjectList {
+    objects: ObjectItem[];
+    constructor(objects?: ObjectItem[]);
+    count(): number;
+    static mergeMultipleInstances(objectLists: ObjectList[]): ObjectList;
+    mergeObjectList(objectList: ObjectList): void;
+    static fromJsonString(jsonStr: string): ObjectList;
+    toJsonString(): string;
+    toTar(): NodeJS.ReadableStream;
+    toReadableStream(): ObjectItemsStream;
+    static fromTar(packStream: NodeJS.ReadableStream): Promise<ObjectList>;
+    static fromTarToObjectStream(packStream: NodeJS.ReadableStream): ObjectItemsStream;
+    static fromObjectStreamToTar(readable: Readable, scopeName: string): any;
+    static fromReadableStream(readable: ObjectItemsStream): Promise<ObjectList>;
+    /**
+     * the opposite of this.combineScopeAndHash
+     */
+    static extractScopeAndHash(name: string): {
+        scope?: string;
+        ref: Ref;
+    };
+    /**
+     * the opposite of this.extractScopeAndHash
+     */
+    static combineScopeAndHash(objectItem: ObjectItem): string;
+    addIfNotExist(objectItems: ObjectItem[]): void;
+    toBitObjects(throwForUnknownTypes?: boolean): Promise<BitObjectList>;
+    static fromBitObjects(bitObjects: BitObject[]): Promise<ObjectList>;
+    addScopeName(scopeName: string): void;
+    splitByScopeName(): {
+        [scopeName: string]: ObjectList;
+    };
+    /**
+     * helps debugging
+     */
+    toConsoleLog(): void;
+}

package/dist/objects/object-list.js

@@ -0,0 +1,369 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ObjectList = exports.FETCH_FORMAT_OBJECT_LIST = void 0;
+function _tarStream() {
+  const data = _interopRequireDefault(require("tar-stream"));
+  _tarStream = function () {
+    return data;
+  };
+  return data;
+}
+function _toolboxPromise() {
+  const data = require("@teambit/toolbox.promise.map-pool");
+  _toolboxPromise = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _stream() {
+  const data = require("stream");
+  _stream = function () {
+    return data;
+  };
+  return data;
+}
+function _object() {
+  const data = _interopRequireDefault(require("./object"));
+  _object = function () {
+    return data;
+  };
+  return data;
+}
+function _bitObjectList() {
+  const data = require("./bit-object-list");
+  _bitObjectList = function () {
+    return data;
+  };
+  return data;
+}
+function _ref() {
+  const data = _interopRequireDefault(require("./ref"));
+  _ref = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy() {
+  const data = require("@teambit/legacy.logger");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _harmonyModules() {
+  const data = require("@teambit/harmony.modules.concurrency");
+  _harmonyModules = function () {
+    return data;
+  };
+  return data;
+}
+function _models() {
+  const data = require("../models");
+  _models = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy2() {
+  const data = require("@teambit/legacy.scope");
+  _legacy2 = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+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); }
+/**
+ * when error occurred during streaming between HTTP server and client, there is no good way to
+ * indicate this other than sending a new file with a special name and the error message.
+ */
+const TAR_STREAM_ERROR_FILENAME = '.BIT.ERROR';
+/**
+ * schema 1.0.0 - added the start and end file with basic info
+ */
+const OBJECT_LIST_CURRENT_SCHEMA = '1.0.0';
+const TAR_STREAM_START_FILENAME = '.BIT.START';
+const TAR_STREAM_END_FILENAME = '.BIT.END';
+const FETCH_FORMAT_OBJECT_LIST = exports.FETCH_FORMAT_OBJECT_LIST = 'ObjectList';
+
+/**
+ * Stream.Readable that operates with objectMode, while each 'data' event emits one ObjectItem object.
+ */
+
+class ObjectList {
+  constructor(objects = []) {
+    this.objects = objects;
+  }
+  count() {
+    return this.objects.length;
+  }
+  static mergeMultipleInstances(objectLists) {
+    const objectList = new ObjectList();
+    objectLists.forEach(objList => objectList.mergeObjectList(objList));
+    return objectList;
+  }
+  mergeObjectList(objectList) {
+    this.addIfNotExist(objectList.objects);
+  }
+  static fromJsonString(jsonStr) {
+    const jsonParsed = JSON.parse(jsonStr);
+    if (!Array.isArray(jsonParsed)) {
+      throw new Error(`fromJsonString expect an array, got ${typeof jsonParsed}`);
+    }
+    jsonParsed.forEach(obj => {
+      obj.ref = new (_ref().default)(obj.ref.hash);
+      obj.buffer = Buffer.from(obj.buffer);
+    });
+    return new ObjectList(jsonParsed);
+  }
+  toJsonString() {
+    return JSON.stringify(this.objects);
+  }
+  toTar() {
+    const pack = _tarStream().default.pack();
+    this.objects.forEach(obj => {
+      pack.entry({
+        name: ObjectList.combineScopeAndHash(obj)
+      }, obj.buffer);
+    });
+    pack.finalize();
+    return pack;
+  }
+  toReadableStream() {
+    return _stream().Readable.from(this.objects);
+  }
+  static async fromTar(packStream) {
+    const extract = _tarStream().default.extract();
+    const objectItems = await new Promise((resolve, reject) => {
+      const objects = [];
+      extract.on('entry', (header, stream, next) => {
+        const data = [];
+        stream.on('data', chunk => {
+          data.push(chunk);
+        });
+        stream.on('end', () => {
+          objects.push(_objectSpread(_objectSpread({}, ObjectList.extractScopeAndHash(header.name)), {}, {
+            buffer: Buffer.concat(data)
+          }));
+          next(); // ready for next entry
+        });
+        stream.on('error', err => reject(err));
+        stream.resume(); // just auto drain the stream
+      });
+      extract.on('finish', () => {
+        resolve(objects);
+      });
+      packStream.pipe(extract);
+    });
+    return new ObjectList(objectItems);
+  }
+  static fromTarToObjectStream(packStream) {
+    const passThrough = new (_stream().PassThrough)({
+      objectMode: true
+    });
+    const extract = _tarStream().default.extract();
+    let startData;
+    let endData;
+    extract.on('entry', (header, stream, next) => {
+      const data = [];
+      stream.on('data', chunk => {
+        data.push(chunk);
+      });
+      stream.on('end', () => {
+        const allData = Buffer.concat(data);
+        if (header.name === TAR_STREAM_ERROR_FILENAME) {
+          passThrough.emit('error', new Error(allData.toString()));
+          return;
+        }
+        if (header.name === TAR_STREAM_START_FILENAME) {
+          startData = JSON.parse(allData.toString());
+          _legacy().logger.debug('fromTarToObjectStream, start getting data', startData);
+          next();
+          return;
+        }
+        if (header.name === TAR_STREAM_END_FILENAME) {
+          endData = JSON.parse(allData.toString());
+          _legacy().logger.debug('fromTarToObjectStream, finished getting data', endData);
+          next();
+          return;
+        }
+        passThrough.write(_objectSpread(_objectSpread({}, ObjectList.extractScopeAndHash(header.name)), {}, {
+          buffer: allData
+        }));
+        next(); // ready for next entry
+      });
+      stream.on('error', err => {
+        passThrough.emit('error', err);
+      });
+      stream.resume(); // just auto drain the stream
+    });
+
+    // not sure if needed
+    extract.on('error', err => {
+      passThrough.emit('error', err);
+    });
+    extract.on('finish', () => {
+      if (startData?.schema === OBJECT_LIST_CURRENT_SCHEMA && !endData) {
+        // wasn't able to find a better way to indicate whether the server aborted the request
+        // see https://github.com/node-fetch/node-fetch/issues/1117
+        passThrough.emit('error', new Error(`server terminated the stream unexpectedly (metadata: ${JSON.stringify(startData)})`));
+      }
+      passThrough.end();
+    });
+    (0, _stream().pipeline)(packStream, extract, err => {
+      if (err) {
+        _legacy().logger.error('fromTarToObjectStream, pipeline', err);
+        passThrough.emit('error', err);
+      } else {
+        _legacy().logger.debug('fromTarToObjectStream, pipeline is completed');
+      }
+    });
+    return passThrough;
+  }
+  static fromObjectStreamToTar(readable, scopeName) {
+    const pack = _tarStream().default.pack();
+    const startFile = {
+      schema: OBJECT_LIST_CURRENT_SCHEMA,
+      scopeName
+    };
+    _legacy().logger.debug('fromObjectStreamToTar, start sending data', startFile);
+    pack.entry({
+      name: TAR_STREAM_START_FILENAME
+    }, JSON.stringify(startFile));
+    let numOfFiles = 0;
+    readable.on('data', obj => {
+      numOfFiles += 1;
+      pack.entry({
+        name: ObjectList.combineScopeAndHash(obj)
+      }, obj.buffer);
+    });
+    readable.on('end', () => {
+      const endFile = {
+        numOfFiles,
+        scopeName
+      };
+      _legacy().logger.debug('fromObjectStreamToTar, finished sending data', endFile);
+      pack.entry({
+        name: TAR_STREAM_END_FILENAME
+      }, JSON.stringify(endFile));
+      pack.finalize();
+    });
+    readable.on('error', err => {
+      const errorMessage = err.message || `unexpected error (${err.name})`;
+      _legacy().logger.error(`ObjectList.fromObjectStreamToTar, streaming an error as a file`, err);
+      pack.entry({
+        name: TAR_STREAM_ERROR_FILENAME
+      }, errorMessage);
+      pack.finalize();
+    });
+    return pack;
+  }
+  static async fromReadableStream(readable) {
+    const objectItems = [];
+    for await (const obj of readable) {
+      objectItems.push(obj);
+    }
+    return new ObjectList(objectItems);
+  }
+
+  /**
+   * the opposite of this.combineScopeAndHash
+   */
+  static extractScopeAndHash(name) {
+    const nameSplit = name.split('/');
+    const hasScope = nameSplit.length > 1;
+    return {
+      scope: hasScope ? nameSplit[0] : undefined,
+      ref: new (_ref().default)(hasScope ? nameSplit[1] : nameSplit[0])
+    };
+  }
+  /**
+   * the opposite of this.extractScopeAndHash
+   */
+  static combineScopeAndHash(objectItem) {
+    const scope = objectItem.scope ? `${objectItem.scope}/` : '';
+    return `${scope}${objectItem.ref.hash}`;
+  }
+  addIfNotExist(objectItems) {
+    objectItems.forEach(objectItem => {
+      const exists = this.objects.find(object => object.ref.isEqual(objectItem.ref) && object.scope === objectItem.scope);
+      if (!exists) {
+        this.objects.push(objectItem);
+      }
+    });
+  }
+  async toBitObjects(throwForUnknownTypes = false) {
+    const concurrency = (0, _harmonyModules().concurrentIOLimit)();
+    const bitObjects = await (0, _toolboxPromise().pMapPool)(this.objects, async object => {
+      try {
+        return await _object().default.parseObject(object.buffer);
+      } catch (err) {
+        if (throwForUnknownTypes || !(err instanceof _legacy2().UnknownObjectType)) {
+          throw err;
+        }
+        _legacy().logger.error(`toBitObjects, unable to parse object of type ${err.type}, ignoring it. please update your bit version`);
+        return null;
+      }
+    }, {
+      concurrency
+    });
+    return new (_bitObjectList().BitObjectList)((0, _lodash().compact)(bitObjects));
+  }
+  static async fromBitObjects(bitObjects) {
+    const concurrency = (0, _harmonyModules().concurrentIOLimit)();
+    const objectItems = await (0, _toolboxPromise().pMapPool)(bitObjects, async obj => ({
+      ref: obj.hash(),
+      buffer: await obj.compress(),
+      type: obj.getType()
+    }), {
+      concurrency
+    });
+    return new ObjectList(objectItems);
+  }
+  addScopeName(scopeName) {
+    this.objects.forEach(object => {
+      object.scope = scopeName;
+    });
+  }
+  splitByScopeName() {
+    const objectListPerScope = {};
+    this.objects.forEach(obj => {
+      if (obj.type === _models().ExportMetadata.name) {
+        return; // no scope for this type. it's general for all export data from all scopes
+      }
+      if (!obj.scope) {
+        throw new Error(`ObjectList: unable to split by scopeName, the scopeName is missing for ${obj.ref.hash}`);
+      }
+      if (objectListPerScope[obj.scope]) {
+        objectListPerScope[obj.scope].addIfNotExist([obj]);
+      } else {
+        objectListPerScope[obj.scope] = new ObjectList([obj]);
+      }
+    });
+    return objectListPerScope;
+  }
+
+  /**
+   * helps debugging
+   */
+  toConsoleLog() {
+    console.log(this.objects.map(o => o.ref.hash).join('\n')); // eslint-disable-line no-console
+  }
+}
+exports.ObjectList = ObjectList;
+
+//# sourceMappingURL=object-list.js.map