@teambit/objects 0.0.0-15acf3f9b295a985a00bf4c313c939bf7adc1310

package/dist/fixtures/version-model-extended.json

@@ -0,0 +1,48 @@
+{
+    "files": [
+        {
+            "file": "041875a4daae4a64415374062f7a4bd2eac3f751",
+            "relativePath": "bar/foo.ts",
+            "name": "foo.ts",
+            "test": false
+        }
+    ],
+    "mainFile": "bar/foo.ts",
+    "bindingPrefix": "@bit",
+    "log": {
+        "message": "tag-message",
+        "date": "1527523854385",
+        "username": "David First",
+        "email": "david@bit.dev"
+    },
+    "ci": {},
+    "docs": [],
+    "dependencies": [
+        {
+            "id": { "scope": "23th85mi-remote", "name": "/utils/is-string", "version": "0.0.1" },
+            "relativePaths": [
+                {
+                    "sourceRelativePath": "utils/is-string.ts",
+                    "destinationRelativePath": "utils/is-string.ts",
+                    "importSpecifiers": [
+                        {
+                            "mainFile": {
+                                "isDefault": true,
+                                "name": "isString"
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    ],
+    "devDependencies": [],
+    "flattenedDependencies": [
+        { "scope": "23th85mi-remote", "name": "utils/is-type", "version": "0.0.1" },
+        { "scope": "23th85mi-remote", "name": "utils/is-string", "version": "0.0.1" }
+    ],
+    "flattenedDevDependencies": [],
+    "packageDependencies": {},
+    "devPackageDependencies": {},
+    "peerPackageDependencies": {}
+}

package/dist/fixtures/version-model-object.json

@@ -0,0 +1,87 @@
+{
+  "files": [{
+      "file": "3ef84ee58242de1b3feadfab4d12a7018de69e93",
+      "relativePath": "impl.js",
+      "name": "impl.js",
+      "test": false
+  }, {
+      "file": "b0f492d50dff231d3d50872f1fe42901a26be66e",
+      "relativePath": "spec.js",
+      "name": "spec.js",
+      "test": true
+  }],
+  "mainFile": "impl.js",
+  "dists": [{
+      "file": "aa633b24c97bb53dcd52b0ef5ac7f6aa7b7c85fa",
+      "relativePath": "dist.js",
+      "name": "dist.js",
+      "test": false
+  }],
+  "compiler": "bit.envs/compilers/babel",
+  "bindingPrefix": "@bit",
+  "tester": "bit.envs/mocha/react",
+  "log": {
+      "message": "init",
+      "date": "1497953762445",
+      "username": "David First",
+      "email": "david@bitsrc.io"
+  },
+  "ci": {
+      "startTime": "1497953909560",
+      "endTime": "1497953937808"
+  },
+  "specsResults": [{
+      "tests": [{
+          "title": "QuerySelectorAll should use GetElementByTagName",
+          "pass": true,
+          "err": null,
+          "duration": 5
+      }, {
+          "title": "QuerySelectorAll should use GetElementById",
+          "pass": true,
+          "err": null,
+          "duration": 2
+      }, {
+          "title": "QuerySelectorAll should use GetElementsByClassName",
+          "pass": true,
+          "err": null,
+          "duration": 2
+      }, {
+          "title": "QuerySelectorAll should use qsa for complex selectors",
+          "pass": true,
+          "err": null,
+          "duration": 9
+      }],
+      "stats": {
+          "start": "2017-06-20T10:18:57.361Z",
+          "end": "2017-06-20T10:18:57.792Z",
+          "duration": 431
+      },
+      "pass": true,
+      "specFile": "spec.js"
+  }],
+  "docs": [{
+      "name": "querySelectorAll",
+      "description": "# Returns all elements in the document that matches a specified CSS selector.",
+      "args": [{
+          "description": null,
+          "type": "object",
+          "name": "element"
+      }, {
+          "description": null,
+          "type": "string",
+          "name": "selector"
+      }],
+      "returns": {},
+      "access": "public",
+      "examples": [],
+      "static": false
+  }],
+  "dependencies": [],
+  "devDependencies": [],
+  "flattenedDependencies": [],
+  "flattenedDevDependencies": [],
+  "packageDependencies": {},
+  "devPackageDependencies": {},
+  "peerPackageDependencies": {}
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { ModelComponent, ScopeMeta, Source, Version, Symlink, Lane, ExportMetadata, VersionHistory, LaneHistory, } from './models';
+export { BitObject, BitRawObject, Ref, Repository } from './objects';
+export { ComponentLog, ScopeListItem, AddVersionOpts, ComponentProps, VERSION_ZERO } from './models/model-component';
+export { ComponentItem, IndexType, LaneItem } from './objects/scope-index';
+export { ObjectItem, ObjectList, ObjectItemsStream } from './objects/object-list';
+export { BitObjectList } from './objects/bit-object-list';
+export { LaneComponent, Log as LaneLog, LaneReadmeComponent } from './models/lane';
+export { DependenciesGraph, type PackagesMap, type PackageAttributes, type DependencyEdge, type DependencyNeighbour, } from './models/dependencies-graph';
+export { DepEdge, DepEdgeType, SourceFileModel, Log } from './models/version';
+export { ComponentWithCollectOptions, ObjectsReadableGenerator } from './objects/objects-readable-generator';
+export { ScopeIndex } from './objects/scope-index';
+export { VersionHistoryGraph } from './models/version-history';
+export { VersionParents, versionParentsToGraph } from './models/version-history';
+export { HistoryItem } from './models/lane-history';
+export { IdGraph, objectListToGraph, bitObjectListToGraph } from './objects/object-list-to-graph';
+import { ObjectsAspect } from './objects.aspect';
+export type { ObjectsMain } from './objects.main.runtime';
+export default ObjectsAspect;
+export { ObjectsAspect };

package/dist/index.js

@@ -0,0 +1,371 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AddVersionOpts", {
+  enumerable: true,
+  get: function () {
+    return _modelComponent().AddVersionOpts;
+  }
+});
+Object.defineProperty(exports, "BitObject", {
+  enumerable: true,
+  get: function () {
+    return _objects().BitObject;
+  }
+});
+Object.defineProperty(exports, "BitObjectList", {
+  enumerable: true,
+  get: function () {
+    return _bitObjectList().BitObjectList;
+  }
+});
+Object.defineProperty(exports, "BitRawObject", {
+  enumerable: true,
+  get: function () {
+    return _objects().BitRawObject;
+  }
+});
+Object.defineProperty(exports, "ComponentItem", {
+  enumerable: true,
+  get: function () {
+    return _scopeIndex().ComponentItem;
+  }
+});
+Object.defineProperty(exports, "ComponentLog", {
+  enumerable: true,
+  get: function () {
+    return _modelComponent().ComponentLog;
+  }
+});
+Object.defineProperty(exports, "ComponentProps", {
+  enumerable: true,
+  get: function () {
+    return _modelComponent().ComponentProps;
+  }
+});
+Object.defineProperty(exports, "ComponentWithCollectOptions", {
+  enumerable: true,
+  get: function () {
+    return _objectsReadableGenerator().ComponentWithCollectOptions;
+  }
+});
+Object.defineProperty(exports, "DepEdge", {
+  enumerable: true,
+  get: function () {
+    return _version().DepEdge;
+  }
+});
+Object.defineProperty(exports, "DepEdgeType", {
+  enumerable: true,
+  get: function () {
+    return _version().DepEdgeType;
+  }
+});
+Object.defineProperty(exports, "DependenciesGraph", {
+  enumerable: true,
+  get: function () {
+    return _dependenciesGraph().DependenciesGraph;
+  }
+});
+Object.defineProperty(exports, "ExportMetadata", {
+  enumerable: true,
+  get: function () {
+    return _models().ExportMetadata;
+  }
+});
+Object.defineProperty(exports, "HistoryItem", {
+  enumerable: true,
+  get: function () {
+    return _laneHistory().HistoryItem;
+  }
+});
+Object.defineProperty(exports, "IdGraph", {
+  enumerable: true,
+  get: function () {
+    return _objectListToGraph().IdGraph;
+  }
+});
+Object.defineProperty(exports, "IndexType", {
+  enumerable: true,
+  get: function () {
+    return _scopeIndex().IndexType;
+  }
+});
+Object.defineProperty(exports, "Lane", {
+  enumerable: true,
+  get: function () {
+    return _models().Lane;
+  }
+});
+Object.defineProperty(exports, "LaneComponent", {
+  enumerable: true,
+  get: function () {
+    return _lane().LaneComponent;
+  }
+});
+Object.defineProperty(exports, "LaneHistory", {
+  enumerable: true,
+  get: function () {
+    return _models().LaneHistory;
+  }
+});
+Object.defineProperty(exports, "LaneItem", {
+  enumerable: true,
+  get: function () {
+    return _scopeIndex().LaneItem;
+  }
+});
+Object.defineProperty(exports, "LaneLog", {
+  enumerable: true,
+  get: function () {
+    return _lane().Log;
+  }
+});
+Object.defineProperty(exports, "LaneReadmeComponent", {
+  enumerable: true,
+  get: function () {
+    return _lane().LaneReadmeComponent;
+  }
+});
+Object.defineProperty(exports, "Log", {
+  enumerable: true,
+  get: function () {
+    return _version().Log;
+  }
+});
+Object.defineProperty(exports, "ModelComponent", {
+  enumerable: true,
+  get: function () {
+    return _models().ModelComponent;
+  }
+});
+Object.defineProperty(exports, "ObjectItem", {
+  enumerable: true,
+  get: function () {
+    return _objectList().ObjectItem;
+  }
+});
+Object.defineProperty(exports, "ObjectItemsStream", {
+  enumerable: true,
+  get: function () {
+    return _objectList().ObjectItemsStream;
+  }
+});
+Object.defineProperty(exports, "ObjectList", {
+  enumerable: true,
+  get: function () {
+    return _objectList().ObjectList;
+  }
+});
+Object.defineProperty(exports, "ObjectsAspect", {
+  enumerable: true,
+  get: function () {
+    return _objects2().ObjectsAspect;
+  }
+});
+Object.defineProperty(exports, "ObjectsReadableGenerator", {
+  enumerable: true,
+  get: function () {
+    return _objectsReadableGenerator().ObjectsReadableGenerator;
+  }
+});
+Object.defineProperty(exports, "Ref", {
+  enumerable: true,
+  get: function () {
+    return _objects().Ref;
+  }
+});
+Object.defineProperty(exports, "Repository", {
+  enumerable: true,
+  get: function () {
+    return _objects().Repository;
+  }
+});
+Object.defineProperty(exports, "ScopeIndex", {
+  enumerable: true,
+  get: function () {
+    return _scopeIndex().ScopeIndex;
+  }
+});
+Object.defineProperty(exports, "ScopeListItem", {
+  enumerable: true,
+  get: function () {
+    return _modelComponent().ScopeListItem;
+  }
+});
+Object.defineProperty(exports, "ScopeMeta", {
+  enumerable: true,
+  get: function () {
+    return _models().ScopeMeta;
+  }
+});
+Object.defineProperty(exports, "Source", {
+  enumerable: true,
+  get: function () {
+    return _models().Source;
+  }
+});
+Object.defineProperty(exports, "SourceFileModel", {
+  enumerable: true,
+  get: function () {
+    return _version().SourceFileModel;
+  }
+});
+Object.defineProperty(exports, "Symlink", {
+  enumerable: true,
+  get: function () {
+    return _models().Symlink;
+  }
+});
+Object.defineProperty(exports, "VERSION_ZERO", {
+  enumerable: true,
+  get: function () {
+    return _modelComponent().VERSION_ZERO;
+  }
+});
+Object.defineProperty(exports, "Version", {
+  enumerable: true,
+  get: function () {
+    return _models().Version;
+  }
+});
+Object.defineProperty(exports, "VersionHistory", {
+  enumerable: true,
+  get: function () {
+    return _models().VersionHistory;
+  }
+});
+Object.defineProperty(exports, "VersionHistoryGraph", {
+  enumerable: true,
+  get: function () {
+    return _versionHistory().VersionHistoryGraph;
+  }
+});
+Object.defineProperty(exports, "VersionParents", {
+  enumerable: true,
+  get: function () {
+    return _versionHistory().VersionParents;
+  }
+});
+Object.defineProperty(exports, "bitObjectListToGraph", {
+  enumerable: true,
+  get: function () {
+    return _objectListToGraph().bitObjectListToGraph;
+  }
+});
+exports.default = void 0;
+Object.defineProperty(exports, "objectListToGraph", {
+  enumerable: true,
+  get: function () {
+    return _objectListToGraph().objectListToGraph;
+  }
+});
+Object.defineProperty(exports, "versionParentsToGraph", {
+  enumerable: true,
+  get: function () {
+    return _versionHistory().versionParentsToGraph;
+  }
+});
+function _models() {
+  const data = require("./models");
+  _models = function () {
+    return data;
+  };
+  return data;
+}
+function _objects() {
+  const data = require("./objects");
+  _objects = function () {
+    return data;
+  };
+  return data;
+}
+function _modelComponent() {
+  const data = require("./models/model-component");
+  _modelComponent = function () {
+    return data;
+  };
+  return data;
+}
+function _scopeIndex() {
+  const data = require("./objects/scope-index");
+  _scopeIndex = function () {
+    return data;
+  };
+  return data;
+}
+function _objectList() {
+  const data = require("./objects/object-list");
+  _objectList = function () {
+    return data;
+  };
+  return data;
+}
+function _bitObjectList() {
+  const data = require("./objects/bit-object-list");
+  _bitObjectList = function () {
+    return data;
+  };
+  return data;
+}
+function _lane() {
+  const data = require("./models/lane");
+  _lane = function () {
+    return data;
+  };
+  return data;
+}
+function _dependenciesGraph() {
+  const data = require("./models/dependencies-graph");
+  _dependenciesGraph = function () {
+    return data;
+  };
+  return data;
+}
+function _version() {
+  const data = require("./models/version");
+  _version = function () {
+    return data;
+  };
+  return data;
+}
+function _objectsReadableGenerator() {
+  const data = require("./objects/objects-readable-generator");
+  _objectsReadableGenerator = function () {
+    return data;
+  };
+  return data;
+}
+function _versionHistory() {
+  const data = require("./models/version-history");
+  _versionHistory = function () {
+    return data;
+  };
+  return data;
+}
+function _laneHistory() {
+  const data = require("./models/lane-history");
+  _laneHistory = function () {
+    return data;
+  };
+  return data;
+}
+function _objectListToGraph() {
+  const data = require("./objects/object-list-to-graph");
+  _objectListToGraph = function () {
+    return data;
+  };
+  return data;
+}
+function _objects2() {
+  const data = require("./objects.aspect");
+  _objects2 = function () {
+    return data;
+  };
+  return data;
+}
+var _default = exports.default = _objects2().ObjectsAspect;
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_models","data","require","_objects","_modelComponent","_scopeIndex","_objectList","_bitObjectList","_lane","_dependenciesGraph","_version","_objectsReadableGenerator","_versionHistory","_laneHistory","_objectListToGraph","_objects2","_default","exports","default","ObjectsAspect"],"sources":["index.ts"],"sourcesContent":["export {\n  ModelComponent,\n  ScopeMeta,\n  Source,\n  Version,\n  Symlink,\n  Lane,\n  ExportMetadata,\n  VersionHistory,\n  LaneHistory,\n} from './models';\nexport { BitObject, BitRawObject, Ref, Repository } from './objects';\nexport { ComponentLog, ScopeListItem, AddVersionOpts, ComponentProps, VERSION_ZERO } from './models/model-component';\nexport { ComponentItem, IndexType, LaneItem } from './objects/scope-index';\nexport { ObjectItem, ObjectList, ObjectItemsStream } from './objects/object-list';\nexport { BitObjectList } from './objects/bit-object-list';\nexport { LaneComponent, Log as LaneLog, LaneReadmeComponent } from './models/lane';\nexport {\n  DependenciesGraph,\n  type PackagesMap,\n  type PackageAttributes,\n  type DependencyEdge,\n  type DependencyNeighbour,\n} from './models/dependencies-graph';\nexport { DepEdge, DepEdgeType, SourceFileModel, Log } from './models/version';\nexport { ComponentWithCollectOptions, ObjectsReadableGenerator } from './objects/objects-readable-generator';\nexport { ScopeIndex } from './objects/scope-index';\nexport { VersionHistoryGraph } from './models/version-history';\nexport { VersionParents, versionParentsToGraph } from './models/version-history';\nexport { HistoryItem } from './models/lane-history';\nexport { IdGraph, objectListToGraph, bitObjectListToGraph } from './objects/object-list-to-graph';\n\nimport { ObjectsAspect } from './objects.aspect';\n\nexport type { ObjectsMain } from './objects.main.runtime';\nexport default ObjectsAspect;\nexport { ObjectsAspect };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAAA,QAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,OAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAWA,SAAAE,SAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,QAAA,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,YAAA;EAAA,MAAAJ,IAAA,GAAAC,OAAA;EAAAG,WAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAK,YAAA;EAAA,MAAAL,IAAA,GAAAC,OAAA;EAAAI,WAAA,YAAAA,CAAA;IAAA,OAAAL,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAM,eAAA;EAAA,MAAAN,IAAA,GAAAC,OAAA;EAAAK,cAAA,YAAAA,CAAA;IAAA,OAAAN,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAO,MAAA;EAAA,MAAAP,IAAA,GAAAC,OAAA;EAAAM,KAAA,YAAAA,CAAA;IAAA,OAAAP,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAQ,mBAAA;EAAA,MAAAR,IAAA,GAAAC,OAAA;EAAAO,kBAAA,YAAAA,CAAA;IAAA,OAAAR,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAOA,SAAAS,SAAA;EAAA,MAAAT,IAAA,GAAAC,OAAA;EAAAQ,QAAA,YAAAA,CAAA;IAAA,OAAAT,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAU,0BAAA;EAAA,MAAAV,IAAA,GAAAC,OAAA;EAAAS,yBAAA,YAAAA,CAAA;IAAA,OAAAV,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,SAAAW,gBAAA;EAAA,MAAAX,IAAA,GAAAC,OAAA;EAAAU,eAAA,YAAAA,CAAA;IAAA,OAAAX,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,SAAAY,aAAA;EAAA,MAAAZ,IAAA,GAAAC,OAAA;EAAAW,YAAA,YAAAA,CAAA;IAAA,OAAAZ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAa,mBAAA;EAAA,MAAAb,IAAA,GAAAC,OAAA;EAAAY,kBAAA,YAAAA,CAAA;IAAA,OAAAb,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,SAAAc,UAAA;EAAA,MAAAd,IAAA,GAAAC,OAAA;EAAAa,SAAA,YAAAA,CAAA;IAAA,OAAAd,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAiD,IAAAe,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAGlCC,yBAAa","ignoreList":[]}

package/dist/models/dependencies-graph.d.ts

@@ -0,0 +1,46 @@
+import { PackageInfo } from '@pnpm/lockfile.types';
+export type PackagesMap = Map<string, PackageAttributes>;
+export type PackageAttributes = PackageInfo & {
+    component?: {
+        scope: string;
+        name: string;
+    };
+    requiresBuild?: boolean;
+};
+export type DependencyEdge = {
+    id: string;
+    neighbours: DependencyNeighbour[];
+    attr?: {
+        pkgId?: string;
+        transitivePeerDependencies?: string[];
+    };
+};
+export type DependencyNeighbour = {
+    id: string;
+    /**
+     * This is true when the dependency is from optionalDependencies.
+     */
+    optional?: boolean;
+    name?: string;
+    specifier?: string;
+    lifecycle?: 'runtime' | 'dev';
+};
+export declare class DependenciesGraph {
+    static ROOT_EDGE_ID: string;
+    schemaVersion: string;
+    packages: PackagesMap;
+    edges: DependencyEdge[];
+    constructor({ packages, edges, schemaVersion, }: {
+        packages: PackagesMap;
+        edges: DependencyEdge[];
+        schemaVersion?: string;
+    });
+    serialize(): string;
+    static deserialize(data: string): DependenciesGraph | undefined;
+    merge(graph: DependenciesGraph): void;
+    isEmpty(): boolean;
+    /**
+     * Returns the edge related to the root component
+     */
+    findRootEdge(): DependencyEdge | undefined;
+}

package/dist/models/dependencies-graph.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DependenciesGraph = void 0;
+function _semver() {
+  const data = _interopRequireDefault(require("semver"));
+  _semver = function () {
+    return data;
+  };
+  return data;
+}
+function dp() {
+  const data = _interopRequireWildcard(require("@pnpm/dependency-path"));
+  dp = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _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); }
+const DEPENDENCIES_GRAPH_SCHEMA_VERSION = '2.0';
+class DependenciesGraph {
+  constructor({
+    packages,
+    edges,
+    schemaVersion
+  }) {
+    _defineProperty(this, "schemaVersion", void 0);
+    _defineProperty(this, "packages", void 0);
+    _defineProperty(this, "edges", void 0);
+    this.packages = packages;
+    this.edges = edges;
+    this.schemaVersion = schemaVersion ?? DEPENDENCIES_GRAPH_SCHEMA_VERSION;
+  }
+  serialize() {
+    return JSON.stringify({
+      schemaVersion: this.schemaVersion,
+      packages: Object.fromEntries(this.packages.entries()),
+      edges: this.edges
+    });
+  }
+  static deserialize(data) {
+    const parsed = JSON.parse(data);
+    // If the schema version is not supported, then we just ignore the data
+    if (parsed.schemaVersion !== DEPENDENCIES_GRAPH_SCHEMA_VERSION) {
+      return undefined;
+    }
+    return new DependenciesGraph({
+      schemaVersion: parsed.schemaVersion,
+      edges: parsed.edges,
+      packages: new Map(Object.entries(parsed.packages))
+    });
+  }
+  merge(graph) {
+    const directDependencies = graph.findRootEdge()?.neighbours;
+    if (directDependencies) {
+      for (const directDep of directDependencies) {
+        const existingDirectDeps = this.findRootEdge()?.neighbours;
+        if (existingDirectDeps) {
+          const existingDirectDep = existingDirectDeps.find(({
+            name,
+            specifier
+          }) => name === directDep.name && specifier === directDep.specifier);
+          if (existingDirectDep == null) {
+            existingDirectDeps.push(directDep);
+          } else if (existingDirectDep.id !== directDep.id && nodeIdLessThan(existingDirectDep.id, directDep.id)) {
+            existingDirectDep.id = directDep.id;
+          }
+        }
+      }
+    }
+    for (const [newPkgId, newPkgAttr] of graph.packages.entries()) {
+      this.packages.set(newPkgId, newPkgAttr);
+    }
+    this.edges.push(...graph.edges);
+  }
+  isEmpty() {
+    return this.packages.size === 0 && this.edges.length === 0;
+  }
+
+  /**
+   * Returns the edge related to the root component
+   */
+  findRootEdge() {
+    return this.edges.find(({
+      id
+    }) => id === DependenciesGraph.ROOT_EDGE_ID);
+  }
+}
+exports.DependenciesGraph = DependenciesGraph;
+_defineProperty(DependenciesGraph, "ROOT_EDGE_ID", '.');
+function nodeIdLessThan(nodeId1, nodeId2) {
+  const parsed1 = dp().parse(nodeId1);
+  if (!parsed1?.version) return false;
+  const parsed2 = dp().parse(nodeId2);
+  if (!parsed2?.version) return false;
+  return _semver().default.lt(parsed1.version, parsed2.version);
+}
+
+//# sourceMappingURL=dependencies-graph.js.map