@memlab/core 1.1.6 → 1.1.10

package/dist/lib/HeapParser.js

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
- * @lightSyntaxTransform
  * @format
+ * @lightSyntaxTransform
+ * @oncall ws_labs
  */
 'use strict';
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {

package/dist/lib/InternalValueSetter.d.ts

@@ -4,8 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 /** @internal */
 export declare abstract class InternalValueSetter<T> {

package/dist/lib/InternalValueSetter.js

@@ -5,8 +5,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };

package/dist/lib/NodeHeap.d.ts

@@ -4,8 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 import type { IHeapSnapshot } from './Types';
 /**
@@ -22,7 +22,7 @@ import type { IHeapSnapshot } from './Types';
  * * **Examples**:
  * ```typescript
  * import type {IHeapSnapshot, AnyValue} from '@memlab/core';
- * import {config, getNodeInnocentHeap, tagObject} from '@memlab/core';
+ * import {config, takeNodeMinimalHeap, tagObject} from '@memlab/core';
  *
  * test('memory test', async () => {
  *   config.muteConsole = true;
@@ -36,7 +36,7 @@ import type { IHeapSnapshot } from './Types';
  *
  *   o2 = null;
  *
- *   const heap: IHeapSnapshot = await getNodeInnocentHeap();
+ *   const heap: IHeapSnapshot = await takeNodeMinimalHeap();
  *
  *   // expect object with marker "memlab-mark-1" exists
  *   expect(heap.hasObjectWithTag('memlab-mark-1')).toBe(true);
@@ -60,11 +60,11 @@ export declare function tagObject<T extends object>(o: T, tag: string): T;
  * ```typescript
  * import type {IHeapSnapshot} from '@memlab/core';
  * import {dumpNodeHeapSnapshot} from '@memlab/core';
- * import {getHeapFromFile} from '@memlab/heap-analysis';
+ * import {getFullHeapFromFile} from '@memlab/heap-analysis';
  *
  * (async function () {
  *   const heapFile = dumpNodeHeapSnapshot();
- *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+ *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
  * })();
  * ```
  */
@@ -77,19 +77,42 @@ export declare function dumpNodeHeapSnapshot(): string;
  *
  * @returns heap representation without heap analysis meta data.
  *
- * If you need to get the heap snapshot with heap analysis meta data
- * use {@link dumpNodeHeapSnapshot} and {@link getHeapFromFile},
- * for example:
+ * @deprecated
+ * @internal
+ *
+ * If you need to get the heap snapshot with heap analysis meta data, please
+ * use {@link takeNodeFullHeap}.
+ * For example:
  * ```typescript
  * import type {IHeapSnapshot} from '@memlab/core';
- * import {dumpNodeHeapSnapshot} from '@memlab/core';
- * import {getHeapFromFile} from '@memlab/heap-analysis';
+ * import {takeNodeFullHeap} from '@memlab/heap-analysis';
  *
  * (async function () {
- *   const heapFile = dumpNodeHeapSnapshot();
- *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+ *   const heap: IHeapSnapshot = await takeNodeFullHeap();
  * })();
  * ```
  */
 export declare function getNodeInnocentHeap(): Promise<IHeapSnapshot>;
+/**
+ * Take a heap snapshot of the current program state
+ * and parse it as {@link IHeapSnapshot}. Notice that
+ * this API does not calculate some heap analysis meta data
+ * for heap analysis. But this also means faster heap parsing.
+ *
+ * @returns heap representation without heap analysis meta data.
+ *
+ * * **Examples:**
+ * ```typescript
+ * import type {IHeapSnapshot} from '@memlab/core';
+ * import {takeNodeMinimalHeap} from '@memlab/core';
+ *
+ * (async function () {
+ *   const heap: IHeapSnapshot = await takeNodeMinimalHeap();
+ * })();
+ * ```
+ *
+ * If you need to get the heap snapshot with heap analysis meta data, please
+ * use {@link getFullHeapFromFile}.
+ */
+export declare function takeNodeMinimalHeap(): Promise<IHeapSnapshot>;
 //# sourceMappingURL=NodeHeap.d.ts.map

package/dist/lib/NodeHeap.js

@@ -5,8 +5,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -21,18 +21,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNodeInnocentHeap = exports.dumpNodeHeapSnapshot = exports.tagObject = void 0;
+exports.takeNodeMinimalHeap = exports.getNodeInnocentHeap = exports.dumpNodeHeapSnapshot = exports.tagObject = void 0;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const v8_1 = __importDefault(require("v8"));
 const FileManager_1 = __importDefault(require("./FileManager"));
 const Utils_1 = __importDefault(require("./Utils"));
-class MemLabTaggedStore {
-    constructor() {
-        this.taggedObjects = Object.create(null);
-    }
-}
-const store = new MemLabTaggedStore();
+const MemLabTagStore_1 = __importDefault(require("./heap-data/MemLabTagStore"));
 /**
  * Tags a string marker to an object instance, which can later be checked by
  * {@link hasObjectWithTag}. This API does not modify the object instance in
@@ -47,7 +42,7 @@ const store = new MemLabTaggedStore();
  * * **Examples**:
  * ```typescript
  * import type {IHeapSnapshot, AnyValue} from '@memlab/core';
- * import {config, getNodeInnocentHeap, tagObject} from '@memlab/core';
+ * import {config, takeNodeMinimalHeap, tagObject} from '@memlab/core';
  *
  * test('memory test', async () => {
  *   config.muteConsole = true;
@@ -61,7 +56,7 @@ const store = new MemLabTaggedStore();
  *
  *   o2 = null;
  *
- *   const heap: IHeapSnapshot = await getNodeInnocentHeap();
+ *   const heap: IHeapSnapshot = await takeNodeMinimalHeap();
  *
  *   // expect object with marker "memlab-mark-1" exists
  *   expect(heap.hasObjectWithTag('memlab-mark-1')).toBe(true);
@@ -73,10 +68,7 @@ const store = new MemLabTaggedStore();
  * ```
  */
 function tagObject(o, tag) {
-    if (!store.taggedObjects[tag]) {
-        store.taggedObjects[tag] = new WeakSet();
-    }
-    store.taggedObjects[tag].add(o);
+    MemLabTagStore_1.default.tagObject(o, tag);
     return o;
 }
 exports.tagObject = tagObject;
@@ -92,16 +84,20 @@ exports.tagObject = tagObject;
  * ```typescript
  * import type {IHeapSnapshot} from '@memlab/core';
  * import {dumpNodeHeapSnapshot} from '@memlab/core';
- * import {getHeapFromFile} from '@memlab/heap-analysis';
+ * import {getFullHeapFromFile} from '@memlab/heap-analysis';
  *
  * (async function () {
  *   const heapFile = dumpNodeHeapSnapshot();
- *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+ *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
  * })();
  * ```
  */
 function dumpNodeHeapSnapshot() {
-    const file = path_1.default.join(FileManager_1.default.generateTmpHeapDir(), `nodejs.heapsnapshot`);
+    const randomID = `Math.random()`.replace('0.', '');
+    const file = path_1.default.join(FileManager_1.default.generateTmpHeapDir(), `nodejs-${randomID}.heapsnapshot`);
+    if (fs_extra_1.default.existsSync(file)) {
+        fs_extra_1.default.removeSync(file);
+    }
     v8_1.default.writeHeapSnapshot(file);
     return file;
 }
@@ -114,17 +110,18 @@ exports.dumpNodeHeapSnapshot = dumpNodeHeapSnapshot;
  *
  * @returns heap representation without heap analysis meta data.
  *
- * If you need to get the heap snapshot with heap analysis meta data
- * use {@link dumpNodeHeapSnapshot} and {@link getHeapFromFile},
- * for example:
+ * @deprecated
+ * @internal
+ *
+ * If you need to get the heap snapshot with heap analysis meta data, please
+ * use {@link takeNodeFullHeap}.
+ * For example:
  * ```typescript
  * import type {IHeapSnapshot} from '@memlab/core';
- * import {dumpNodeHeapSnapshot} from '@memlab/core';
- * import {getHeapFromFile} from '@memlab/heap-analysis';
+ * import {takeNodeFullHeap} from '@memlab/heap-analysis';
  *
  * (async function () {
- *   const heapFile = dumpNodeHeapSnapshot();
- *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+ *   const heap: IHeapSnapshot = await takeNodeFullHeap();
  * })();
  * ```
  */
@@ -141,3 +138,37 @@ function getNodeInnocentHeap() {
     });
 }
 exports.getNodeInnocentHeap = getNodeInnocentHeap;
+/**
+ * Take a heap snapshot of the current program state
+ * and parse it as {@link IHeapSnapshot}. Notice that
+ * this API does not calculate some heap analysis meta data
+ * for heap analysis. But this also means faster heap parsing.
+ *
+ * @returns heap representation without heap analysis meta data.
+ *
+ * * **Examples:**
+ * ```typescript
+ * import type {IHeapSnapshot} from '@memlab/core';
+ * import {takeNodeMinimalHeap} from '@memlab/core';
+ *
+ * (async function () {
+ *   const heap: IHeapSnapshot = await takeNodeMinimalHeap();
+ * })();
+ * ```
+ *
+ * If you need to get the heap snapshot with heap analysis meta data, please
+ * use {@link getFullHeapFromFile}.
+ */
+function takeNodeMinimalHeap() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const file = dumpNodeHeapSnapshot();
+        const snapshot = yield Utils_1.default.getSnapshotFromFile(file, {
+            buildNodeIdIndex: true,
+        });
+        fs_extra_1.default.unlink(file, () => {
+            // do nothing
+        });
+        return snapshot;
+    });
+}
+exports.takeNodeMinimalHeap = takeNodeMinimalHeap;

package/dist/lib/PackageInfoLoader.js

@@ -19,8 +19,8 @@ exports.PackageInfoLoader = void 0;
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));

package/dist/lib/ProcessManager.d.ts

@@ -4,8 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 import type { Command, Optional } from './Types';
 declare type Options = {

package/dist/lib/ProcessManager.js

@@ -5,8 +5,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };

package/dist/lib/Serializer.d.ts

@@ -4,8 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 import { E2EStepInfo, HeapNodeIdSet, IHeapEdge, IHeapNode, IHeapSnapshot, ISerializedInfo, LeakTracePathItem, Nullable } from './Types';
 declare type JSONifyArgs = {

package/dist/lib/Serializer.js

@@ -5,8 +5,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };

package/dist/lib/StringLoader.d.ts

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
- * @lightSyntaxTransform
  * @format
+ * @lightSyntaxTransform
+ * @oncall ws_labs
  */
 /// <reference types="node" />
 declare type ReadFileOptions = {

package/dist/lib/StringLoader.js

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
- * @lightSyntaxTransform
  * @format
+ * @lightSyntaxTransform
+ * @oncall ws_labs
  */
 'use strict';
 var __importDefault = (this && this.__importDefault) || function (mod) {

package/dist/lib/Types.d.ts

@@ -4,8 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 import { ParsedArgs } from 'minimist';
 import type { LaunchOptions, Page } from 'puppeteer';
@@ -807,6 +807,13 @@ export declare type RunMetaInfo = {
  * {@link IHeapNode} and {@link IHeapEdge}.
  */
 export interface IHeapSnapshot {
+    /**
+     * flag indicating if the heap snapshot has included
+     * the post-processing meta data (e.g., shortest path to GC root,
+     * dominator info and retainer size etc.)
+     * @internal
+     */
+    isProcessed: boolean;
     /** @internal */
     snapshot: RawHeapSnapshot;
     /**
@@ -819,11 +826,11 @@ export interface IHeapSnapshot {
      * ```typescript
      * import type {IHeapSnapshot, IHeapNode} from '@memlab/core';
      * import {dumpNodeHeapSnapshot} from '@memlab/core';
-     * import {getHeapFromFile} from '@memlab/heap-analysis';
+     * import {getFullHeapFromFile} from '@memlab/heap-analysis';
      *
      * (async function () {
      *   const heapFile = dumpNodeHeapSnapshot();
-     *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+     *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
      *
      *   // get the total number of heap objects
      *   heap.nodes.length;
@@ -845,11 +852,11 @@ export interface IHeapSnapshot {
      * ```typescript
      * import type {IHeapSnapshot, IHeapEdge} from '@memlab/core';
      * import {dumpNodeHeapSnapshot} from '@memlab/core';
-     * import {getHeapFromFile} from '@memlab/heap-analysis';
+     * import {getFullHeapFromFile} from '@memlab/heap-analysis';
      *
      * (async function () {
      *   const heapFile = dumpNodeHeapSnapshot();
-     *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+     *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
      *
      *   // get the total number of heap references
      *   heap.edges.length;
@@ -871,11 +878,11 @@ export interface IHeapSnapshot {
      * ```typescript
      * import type {IHeapSnapshot} from '@memlab/core';
      * import {dumpNodeHeapSnapshot} from '@memlab/core';
-     * import {getHeapFromFile} from '@memlab/heap-analysis';
+     * import {getFullHeapFromFile} from '@memlab/heap-analysis';
      *
      * (async function () {
      *   const heapFile = dumpNodeHeapSnapshot();
-     *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+     *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
      *
      *   const node = heap.getNodeById(351);
      *   node?.id; // should be 351
@@ -893,7 +900,7 @@ export interface IHeapSnapshot {
      * ```typescript
      * // save as example.test.ts
      * import type {IHeapSnapshot, Nullable} from '@memlab/core';
-     * import {config, getNodeInnocentHeap} from '@memlab/core';
+     * import {config, takeNodeMinimalHeap} from '@memlab/core';
      *
      * class TestObject {
      *   public arr1 = [1, 2, 3];
@@ -905,7 +912,7 @@ export interface IHeapSnapshot {
      *
      *   let obj: Nullable<TestObject> = new TestObject();
      *   // get a heap snapshot of the current program state
-     *   let heap: IHeapSnapshot = await getNodeInnocentHeap();
+     *   let heap: IHeapSnapshot = await takeNodeMinimalHeap();
      *
      *   // call some function that may add references to obj
      *   rabbitHole(obj)
@@ -913,7 +920,7 @@ export interface IHeapSnapshot {
      *   expect(heap.hasObjectWithClassName('TestObject')).toBe(true);
      *   obj = null;
      *
-     *   heap = await getNodeInnocentHeap();
+     *   heap = await takeNodeMinimalHeap();
      *   // if rabbitHole does not have any side effect that
      *   // adds new references to obj, then obj can be GCed
      *   expect(heap.hasObjectWithClassName('TestObject')).toBe(false);
@@ -932,7 +939,7 @@ export interface IHeapSnapshot {
      * * **Examples**:
      * ```typescript
      * import type {IHeapSnapshot} from '@memlab/core';
-     * import {getNodeInnocentHeap} from '@memlab/core';
+     * import {takeNodeMinimalHeap} from '@memlab/core';
      *
      * class TestObject {
      *   public arr1 = [1, 2, 3];
@@ -942,7 +949,7 @@ export interface IHeapSnapshot {
      * (async function () {
      *   const obj = new TestObject();
      *   // get a heap snapshot of the current program state
-     *   const heap: IHeapSnapshot = await getNodeInnocentHeap();
+     *   const heap: IHeapSnapshot = await takeNodeMinimalHeap();
      *
      *   const node = heap.getAnyObjectWithClassName('TestObject');
      *   console.log(node?.name); // should be 'TestObject'
@@ -961,14 +968,14 @@ export interface IHeapSnapshot {
      * ```typescript
      * import type {IHeapSnapshot} from '@memlab/core';
      * import {dumpNodeHeapSnapshot} from '@memlab/core';
-     * import {getHeapFromFile} from '@memlab/heap-analysis';
+     * import {getFullHeapFromFile} from '@memlab/heap-analysis';
      *
      * (async function () {
      *   // eslint-disable-next-line @typescript-eslint/no-unused-vars
      *   const object = {'memlab-test-heap-property': 'memlab-test-heap-value'};
      *
      *   const heapFile = dumpNodeHeapSnapshot();
-     *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+     *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
      *
      *   // should be true
      *   console.log(heap.hasObjectWithPropertyName('memlab-test-heap-property'));
@@ -988,7 +995,7 @@ export interface IHeapSnapshot {
      *
      * ```typescript
      * import type {IHeapSnapshot, AnyValue} from '@memlab/core';
-     * import {config, getNodeInnocentHeap, tagObject} from '@memlab/core';
+     * import {config, takeNodeMinimalHeap, tagObject} from '@memlab/core';
      *
      * test('memory test', async () => {
      *   config.muteConsole = true;
@@ -1002,7 +1009,7 @@ export interface IHeapSnapshot {
      *
      *   o2 = null;
      *
-     *   const heap: IHeapSnapshot = await getNodeInnocentHeap();
+     *   const heap: IHeapSnapshot = await takeNodeMinimalHeap();
      *
      *   // expect object with marker "memlab-mark-1" exists
      *   expect(heap.hasObjectWithTag('memlab-mark-1')).toBe(true);
@@ -1026,16 +1033,16 @@ export interface IHeapSnapshot {
  * @readonly it is not recommended to modify any `IHeapLocation` instance
  *
  * * **Examples**: V8 or hermes heap snapshot can be parsed by the
- * {@link getHeapFromFile} API.
+ * {@link getFullHeapFromFile} API.
  *
  * ```typescript
  * import type {IHeapSnapshot, IHeapNode, IHeapLocation} from '@memlab/core';
  * import {dumpNodeHeapSnapshot} from '@memlab/core';
- * import {getHeapFromFile} from '@memlab/heap-analysis';
+ * import {getFullHeapFromFile} from '@memlab/heap-analysis';
  *
  * (async function () {
  *   const heapFile = dumpNodeHeapSnapshot();
- *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+ *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
  *
  *   // iterate over each node (heap object)
  *   heap.nodes.forEach((node: IHeapNode, i: number) => {
@@ -1088,16 +1095,16 @@ export interface IHeapEdgeBasic {
  * @readonly it is not recommended to modify any `IHeapEdge` instance
  *
  * * **Examples**: V8 or hermes heap snapshot can be parsed by the
- * {@link getHeapFromFile} API.
+ * {@link getFullHeapFromFile} API.
  *
  * ```typescript
  * import type {IHeapSnapshot, IHeapEdge} from '@memlab/core';
  * import {dumpNodeHeapSnapshot} from '@memlab/core';
- * import {getHeapFromFile} from '@memlab/heap-analysis';
+ * import {getFullHeapFromFile} from '@memlab/heap-analysis';
  *
  * (async function () {
  *   const heapFile = dumpNodeHeapSnapshot();
- *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+ *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
  *
  *   // iterate over each edge (JS reference in heap)
  *   heap.edges.forEach((edge: IHeapEdge, i: number) => {
@@ -1151,11 +1158,11 @@ export interface IHeapEdge extends IHeapEdgeBasic {
  * ```typescript
  * import type {IHeapSnapshot, IHeapEdges} from '@memlab/core';
  * import {dumpNodeHeapSnapshot} from '@memlab/core';
- * import {getHeapFromFile} from '@memlab/heap-analysis';
+ * import {getFullHeapFromFile} from '@memlab/heap-analysis';
  *
  * (async function () {
  *   const heapFile = dumpNodeHeapSnapshot();
- *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+ *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
  *
  *   const edges: IHeapEdges = heap.edges;
  *   edges.length;
@@ -1221,7 +1228,7 @@ export interface IHeapNodeBasic {
  */
 export declare type EdgeIterationCallback = (edge: IHeapEdge) => Optional<{
     stop: boolean;
-}>;
+}> | void;
 /**
  * An `IHeapNode` instance represents a JS heap object in a heap snapshot.
  * A heap snapshot is generally a graph where graph nodes are JS heap objects
@@ -1230,16 +1237,16 @@ export declare type EdgeIterationCallback = (edge: IHeapEdge) => Optional<{
  * @readonly it is not recommended to modify any `IHeapNode` instance
  *
  * * **Examples**: V8 or hermes heap snapshot can be parsed by the
- * {@link getHeapFromFile} API.
+ * {@link getFullHeapFromFile} API.
  *
  * ```typescript
  * import type {IHeapSnapshot, IHeapNode} from '@memlab/core';
  * import {dumpNodeHeapSnapshot} from '@memlab/core';
- * import {getHeapFromFile} from '@memlab/heap-analysis';
+ * import {getFullHeapFromFile} from '@memlab/heap-analysis';
  *
  * (async function () {
  *   const heapFile = dumpNodeHeapSnapshot();
- *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+ *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
  *
  *   // iterate over each node (heap object)
  *   heap.nodes.forEach((node: IHeapNode, i: number) => {
@@ -1294,6 +1301,11 @@ export interface IHeapNode extends IHeapNodeBasic {
      * object (including engine-internal, native, and JS references).
      */
     referrers: IHeapEdge[];
+    /**
+     * returns true if the heap node has been set an incoming edge
+     * which leads to the parent node on the shortest path to GC root.
+     */
+    hasPathEdge: boolean;
     /**
      * The incoming edge which leads to the parent node
      * on the shortest path to GC root.
@@ -1538,16 +1550,16 @@ export interface IHeapNode extends IHeapNodeBasic {
  * @readonly it is not recommended to modify any `IHeapStringNode` instance
  *
  * * **Examples**: V8 or hermes heap snapshot can be parsed by the
- * {@link getHeapFromFile} API.
+ * {@link getFullHeapFromFile} API.
  *
  * ```typescript
  * import type {IHeapSnapshot, IHeapNode, IHeapStringNode} from '@memlab/core';
  * import {dumpNodeHeapSnapshot} from '@memlab/core';
- * import {getHeapFromFile} from '@memlab/heap-analysis';
+ * import {getFullHeapFromFile} from '@memlab/heap-analysis';
  *
  * (async function () {
  *   const heapFile = dumpNodeHeapSnapshot();
- *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+ *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
  *
  *   // iterate over each node (heap object)
  *   heap.nodes.forEach((node: IHeapNode, i: number) => {
@@ -1579,11 +1591,11 @@ export interface IHeapStringNode extends IHeapNode {
  * ```typescript
  * import type {IHeapSnapshot, IHeapNodes} from '@memlab/core';
  * import {dumpNodeHeapSnapshot} from '@memlab/core';
- * import {getHeapFromFile} from '@memlab/heap-analysis';
+ * import {getFullHeapFromFile} from '@memlab/heap-analysis';
  *
  * (async function () {
  *   const heapFile = dumpNodeHeapSnapshot();
- *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+ *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
  *
  *   const nodes: IHeapNodes = heap.nodes;
  *   nodes.length;
@@ -1718,5 +1730,11 @@ export interface IClusterStrategy {
     diffTraces: (newLeakTraces: LeakTrace[], existingLeakTraces: LeakTrace[]) => TraceDiff;
 }
 /** @internal */
+export interface IHeapConfig {
+    isCliInteractiveMode: boolean;
+    currentHeapFile: Optional<string>;
+    currentHeap: Optional<IHeapSnapshot>;
+}
+/** @internal */
 export declare type ErrorWithMessage = Pick<Error, 'message'>;
 //# sourceMappingURL=Types.d.ts.map

package/dist/lib/Types.js

@@ -5,8 +5,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/Utils.d.ts

@@ -4,8 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 import type { HaltOrThrowOptions } from './Types';
 import type { Browser, Page } from 'puppeteer';
@@ -22,6 +22,7 @@ declare function isEssentialEdge(nodeIndex: number, edgeType: string, rootNodeIn
 declare function isFiberNodeDeletionsEdge(edge: IHeapEdge): boolean;
 declare function isBlinkRootNode(node: IHeapNode): boolean;
 declare function isPendingActivityNode(node: IHeapNode): boolean;
+declare function isDOMNodeIncomplete(node: IHeapNode): boolean;
 declare function isRootNode(node: IHeapNode, opt?: AnyOptions): boolean;
 declare function isDirectPropEdge(edge: IHeapEdge): boolean;
 declare function isReturnEdge(edge: IHeapEdge): boolean;
@@ -171,6 +172,7 @@ declare const _default: {
     isDetachedDOMNode: typeof isDetachedDOMNode;
     isDirectPropEdge: typeof isDirectPropEdge;
     isDocumentDOMTreesRoot: typeof isDocumentDOMTreesRoot;
+    isDOMNodeIncomplete: typeof isDOMNodeIncomplete;
     isEssentialEdge: typeof isEssentialEdge;
     isFiberNode: typeof isFiberNode;
     isFiberNodeDeletionsEdge: typeof isFiberNodeDeletionsEdge;