@memlab/core 1.1.4 → 1.1.7

package/dist/lib/Serializer.js

@@ -99,7 +99,7 @@ function JSONifyDetachedHTMLElement(node, args, options) {
     // options for elem.__reactProps$xxx
     const propsOptions = Object.assign({}, options);
     propsOptions.forceJSONifyDepth = 1;
-    for (const edge of node.references) {
+    iterateSelectedEdges(node, (edge) => {
         const key = JSONifyEdgeNameAndType(edge);
         if (Utils_1.default.isReactFiberEdge(edge)) {
             info[key] = JSONifyNode(edge.toNode, args, fiberOptions);
@@ -110,7 +110,8 @@ function JSONifyDetachedHTMLElement(node, args, options) {
         else {
             info[key] = JSONifyNodeInShort(edge.toNode);
         }
-    }
+        return null;
+    });
     return info;
 }
 function calculateReturnTrace(node, cache) {
@@ -128,15 +129,16 @@ function calculateReturnTrace(node, cache) {
 const objectNodeUsefulProps = new Set(['_context']);
 function JSONifyNodeOneLevel(node) {
     const info = Object.create(null);
-    for (const edge of node.references) {
+    iterateSelectedEdges(node, (edge) => {
         const key = JSONifyEdgeNameAndType(edge);
         info[key] = JSONifyNodeShallow(edge.toNode);
-    }
+        return null;
+    });
     return info;
 }
 function JSONifyNodeShallow(node) {
     const info = Object.create(null);
-    for (const edge of node.references) {
+    iterateSelectedEdges(node, (edge) => {
         const key = JSONifyEdgeNameAndType(edge);
         if (objectNodeUsefulProps.has(edge.name_or_index)) {
             info[key] = JSONifyNodeShallow(edge.toNode);
@@ -144,7 +146,8 @@ function JSONifyNodeShallow(node) {
         else {
             info[key] = JSONifyNodeInShort(edge.toNode);
         }
-    }
+        return null;
+    });
     return info;
 }
 const fiberNodeUsefulProps = new Set([
@@ -154,15 +157,17 @@ const fiberNodeUsefulProps = new Set([
 ]);
 function JSONifyFiberNodeShallow(node) {
     const info = Object.create(null);
-    for (const edge of node.references) {
+    iterateSelectedEdges(node, (edge) => {
         const key = JSONifyEdgeNameAndType(edge);
         if (fiberNodeUsefulProps.has(edge.name_or_index) &&
             Utils_1.default.isObjectNode(edge.toNode)) {
             info[key] = JSONifyNodeShallow(edge.toNode);
-            continue;
         }
-        info[key] = JSONifyNodeInShort(edge.toNode);
-    }
+        else {
+            info[key] = JSONifyNodeInShort(edge.toNode);
+        }
+        return null;
+    });
     return info;
 }
 // calculate the summary of return chain of the FiberNode
@@ -187,7 +192,9 @@ function JSONifyFiberNodeReturnTrace(node, args, options) {
         }
         const parentInfo = getNodeNameInJSON(parent, args);
         key = `${key}:  --return (property)--->  ${parentInfo}`;
-        const info = JSONifyFiberNodeShallow(parent);
+        const info = Config_1.default.includeObjectInfoInTraceReturnChain
+            ? JSONifyFiberNodeShallow(parent)
+            : Object.create(null);
         trace[key] = info;
     }
     return trace;
@@ -206,25 +213,27 @@ function JSONifyFiberNode(node, args, options) {
         propsOptions.forceJSONifyDepth = 1;
     }
     propsOptions.forceJSONifyDepth--;
-    for (const edge of node.references) {
+    iterateSelectedEdges(node, (edge) => {
         const key = JSONifyEdgeNameAndType(edge);
         info[key] =
-            propsOptions.forceJSONifyDepth >= 1
+            propsOptions.forceJSONifyDepth && propsOptions.forceJSONifyDepth >= 1
                 ? JSONifyNode(edge.toNode, args, propsOptions)
                 : JSONifyNodeInShort(edge.toNode);
-    }
+        return null;
+    });
     return info;
 }
 function JSONifyClosure(node, args, options) {
     const info = Object.create(null);
-    for (const edge of node.references) {
+    iterateSelectedEdges(node, (edge) => {
         if (edge.name_or_index === 'shared' ||
             edge.name_or_index === 'context' ||
             edge.name_or_index === 'displayName') {
             const key = filterJSONPropName(edge.name_or_index);
             info[key] = JSONifyNode(edge.toNode, args, options);
         }
-    }
+        return null;
+    });
     return info;
 }
 function JSONifyNumberNode(node, 
@@ -238,7 +247,7 @@ _options) {
 }
 function JSONifyCode(node, args, options) {
     const info = Object.create(null);
-    for (const edge of node.references) {
+    iterateSelectedEdges(node, (edge) => {
         if (edge.name_or_index === 'name_or_scope_info' &&
             edge.toNode.name === '(function scope info)') {
             const key = 'variables with non-number values in closure scope chain';
@@ -251,14 +260,15 @@ function JSONifyCode(node, args, options) {
             const key = filterJSONPropName(edge.name_or_index);
             info[key] = JSONifyNode(edge.toNode, args, options);
         }
-    }
+        return null;
+    });
     return info;
 }
 function JSONifyContext(node, args, options) {
     const info = Object.create(null);
     const key = 'variables in scope (used by nested closures)';
     const closure_vars = (info[key] = Object.create(null));
-    for (const edge of node.references) {
+    iterateSelectedEdges(node, (edge) => {
         const key = filterJSONPropName(edge.name_or_index);
         if (edge.type === 'context') {
             closure_vars[key] = JSONifyNodeInShort(edge.toNode);
@@ -266,15 +276,27 @@ function JSONifyContext(node, args, options) {
         else if (edge.type === '') {
             info[key] = JSONifyNode(edge.toNode, args, options);
         }
-    }
+        return null;
+    });
     return info;
 }
+function iterateSelectedEdges(node, callback) {
+    let edgesProcessed = 0;
+    node.forEachReference((edge) => {
+        if (edge.type === 'internal') {
+            if (edge.name_or_index === 'map' || edge.is_index) {
+                return;
+            }
+        }
+        if (edgesProcessed++ > 100) {
+            return { stop: true };
+        }
+        return callback(edge);
+    });
+}
 function JSONifyOrdinaryValue(node, args, options) {
     const info = Object.create(null);
-    for (const edge of node.references) {
-        if (edge.name_or_index === 'map' && edge.type === 'internal') {
-            continue;
-        }
+    iterateSelectedEdges(node, (edge) => {
         const key = JSONifyEdgeNameAndType(edge);
         const toNode = edge.toNode;
         const toNodeName = toNode.name;
@@ -293,7 +315,8 @@ function JSONifyOrdinaryValue(node, args, options) {
         else {
             info[key] = JSONifyNodeInShort(toNode);
         }
-    }
+        return null;
+    });
     return info;
 }
 function JSONifyNode(node, args, options) {

package/dist/lib/Types.d.ts

@@ -32,7 +32,6 @@ export declare type AnyOptions = Record<string, unknown>;
 export declare type UnusedOptions = Record<string, never>;
 /** @internal */
 export declare type Command = [string, string[], AnyOptions];
-export declare type Predicator<T> = (node: T) => boolean;
 /** @internal */
 export declare type HeapNodeIdSet = Set<number>;
 /** @internal */
@@ -86,6 +85,22 @@ export declare type CLIArgs = {
     'local-puppeteer': boolean;
     'snapshot-dir': string;
 };
+/**
+ * the predicate callback is used to decide if a
+ * entity of type `T`.
+ * For more concrete examples on where it is used,
+ * check out {@link findAnyReference}, {@link findAnyReferrer},
+ * and {@link findReferrers}.
+ *
+ * @typeParam T - the type of the entity to be checked
+ * @param entity - the entity to be checked
+ * @returns whether the entity passes the predicate check
+ */
+export declare type Predicator<T> = (entity: T) => boolean;
+/**
+ * Data structure for holding cookies.
+ * For concrete example, check out {@link cookies}.
+ */
 export declare type Cookies = Array<{
     name: string;
     value: string;
@@ -120,6 +135,12 @@ export interface E2EScenarioSynthesizerConstructor {
     new (config: Config): IE2EScenarioSynthesizer;
 }
 /** @internal */
+export interface IPackageInfo {
+    name: string;
+    version: string;
+    packageLocation?: string;
+}
+/** @internal */
 export interface IRunningMode {
     setConfig(config: Config): void;
     beforeRunning(visitPlan: IE2EScenarioVisitPlan): void;
@@ -282,9 +303,10 @@ export interface ILeakFilter {
 /**
  * Lifecycle function callback that is invoked initially once before calling any
  * leak filter function.
+ * For concrete example, check out {@link beforeLeakFilter}.
  *
- * @param snaphost - heap snapshot see {@link IHeapSnapshot}
- * @param leakedNodeIds - the set of leaked object (node) ids.
+ * @param snapshot heap snapshot see {@link IHeapSnapshot}
+ * @param leakedNodeIds the set of leaked object (node) ids.
  */
 export declare type InitLeakFilterCallback = (snapshot: IHeapSnapshot, leakedNodeIds: HeapNodeIdSet) => void;
 /**
@@ -293,6 +315,8 @@ export declare type InitLeakFilterCallback = (snapshot: IHeapSnapshot, leakedNod
  * allocated but not released from the target interaction
  * in the heap snapshot.
  *
+ * For concrete examples, check out {@link leakFilter}.
+ *
  * @param node - the node that is kept alive in the memory in the heap snapshot
  * @param snapshot - the snapshot of target interaction
  * @param leakedNodeIds - the set of leaked node ids
@@ -311,6 +335,11 @@ export declare type LeakFilterCallback = (node: IHeapNode, snapshot: IHeapSnapsh
 /**
  * The callback defines browser interactions which are
  * used by memlab to interact with the web app under test.
+ * For concrete examples, check out {@link action} or {@link back}.
+ *
+ * @param page the puppeteer [`Page`](https://pptr.dev/api/puppeteer.page)
+ * object, which provides APIs to interact with the web browser
+ * @returns no return value
  */
 export declare type InteractionsCallback = (page: Page, args?: OperationArgs) => Promise<void>;
 /**
@@ -451,6 +480,10 @@ export interface IScenario {
      * `back` is the callback function that specifies how memlab should
      * back/revert the `action` callback. Think of it as an undo action.
      *
+     * * **Parameters**:
+     *   * page: `Page` | the puppeteer [`Page`](https://pptr.dev/api/puppeteer.page)
+     *     object, which provides APIs to interact with the web browser
+     *
      * * **Examples**:
      * ```typescript
      * const scenario = {
@@ -674,7 +707,12 @@ export interface IDataBuilder {
 }
 /**
  * Callback function to provide if the page is loaded.
+ * For concrete example, check out {@link isPageLoaded}.
  * @param page - puppeteer's [Page](https://pptr.dev/api/puppeteer.page/) object.
+ * @returns a boolean value, if it returns `true`, memlab will consider
+ * the navigation completes, if it returns `false`, memlab will keep calling
+ * this callback until it returns `true`. This is an async callback, you can
+ * also `await` and returns `true` until some async logic is resolved.
  */
 export declare type CheckPageLoadCallback = (page: Page) => Promise<boolean>;
 /** @internal */
@@ -724,16 +762,42 @@ export declare type E2EStepInfo = IE2EStepBasic & {
     delay?: number;
     metrics: Record<string, number>;
 };
-/** @internal */
+/**
+ * This data structure contains the input configuration for the browser and
+ * output data from the browser. You can retrieve the instance of this type
+ * through {@link RunMetaInfo}.
+ */
 export interface IBrowserInfo {
+    /**
+     * browser version
+     */
     _browserVersion: string;
+    /**
+     * configuration for puppeteer
+     */
     _puppeteerConfig: LaunchOptions;
+    /**
+     * all web console output
+     */
     _consoleMessages: string[];
 }
+/**
+ * This data structure holds the information about memlab run.
+ * You can retrieve the instance of this type through {@link getRunMetaInfo}.
+ */
 export declare type RunMetaInfo = {
+    /** @internal */
     app: string;
+    /** @internal */
     interaction: string;
+    /**
+     * type of the memlab run
+     */
     type: string;
+    /**
+     * input configuration for the browser and
+     * output data from the browser
+     */
     browserInfo: IBrowserInfo;
 };
 /**
@@ -743,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;
     /**
@@ -755,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;
@@ -781,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;
@@ -807,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
@@ -829,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];
@@ -841,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)
@@ -849,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);
@@ -868,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];
@@ -878,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'
@@ -897,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'));
@@ -924,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;
@@ -938,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);
@@ -962,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) => {
@@ -1024,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) => {
@@ -1087,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;
@@ -1148,6 +1219,13 @@ export interface IHeapNodeBasic {
      */
     id: number;
 }
+/**
+ * Executes a provided callback once for JavaScript references.
+ * For concrete examples, check out {@link forEachReference}
+ * or {@link forEachReferrer}.
+ * @param callback the callback for each JavaScript reference from a collection
+ * @returns this API returns void
+ */
 export declare type EdgeIterationCallback = (edge: IHeapEdge) => Optional<{
     stop: boolean;
 }>;
@@ -1159,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) => {
@@ -1467,16 +1545,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) => {
@@ -1508,11 +1586,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;
@@ -1647,5 +1725,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/Utils.js

@@ -390,7 +390,6 @@ function setFiberNodeAttribute(node, flag) {
     if (!node || !isFiberNode(node)) {
         return;
     }
-    // eslint-disable-next-line no-bitwise
     node.attributes |= flag;
 }
 function hasFiberNodeAttribute(node, flag) {
@@ -447,7 +446,6 @@ function filterNodesInPlace(idSet, snapshot, cb) {
 function applyToNodes(idSet, snapshot, cb, options = {}) {
     let ids = Array.from(idSet.keys());
     if (options.shuffle) {
-        // eslint-disable-next-line fb-www/unsafe-math-random
         ids.sort(() => Math.random() - 0.5);
     }
     else if (options.reverse) {
@@ -508,7 +506,6 @@ function loadScenario(filename) {
     }
     let scenario;
     try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
         scenario = require(filepath);
         scenario = checkScenarioInstance(scenario);
         if (scenario.name == null) {
@@ -534,6 +531,12 @@ function handleSnapshotError(e) {
 }
 function getSnapshotFromFile(filename, options) {
     return __awaiter(this, void 0, void 0, function* () {
+        const heapConfig = Config_1.default.heapConfig;
+        if (heapConfig &&
+            heapConfig.currentHeapFile === filename &&
+            heapConfig.currentHeap) {
+            return heapConfig.currentHeap;
+        }
         Console_1.default.overwrite('parsing ' + filename + ' ...');
         let ret = null;
         try {
@@ -812,7 +815,6 @@ function loadRunMetaInfo(metaFile = undefined) {
     try {
         const content = fs_1.default.readFileSync(file, 'UTF-8');
         return JSON.parse(content);
-        // eslint-disable-next-line fb-www/no-unused-catch-bindings
     }
     catch (_) {
         throw haltOrThrow('Run info missing. Please make sure `memlab run` is complete.');
@@ -1271,9 +1273,23 @@ function getSnapshotDirForAnalysis() {
     return dir;
 }
 function getSingleSnapshotFileForAnalysis() {
-    const path = Config_1.default.useExternalSnapshot && Config_1.default.externalSnapshotFilePaths[0]
-        ? Config_1.default.externalSnapshotFilePaths[0]
-        : getSnapshotFilePathWithTabType(/(final)|(target)|(baseline)/);
+    let path = null;
+    // if an external snapshot file is specified
+    if (Config_1.default.useExternalSnapshot &&
+        Config_1.default.externalSnapshotFilePaths.length > 0) {
+        path =
+            Config_1.default.externalSnapshotFilePaths[Config_1.default.externalSnapshotFilePaths.length - 1];
+        // if running in interactive heap analysis mode
+    }
+    else if (Config_1.default.heapConfig &&
+        Config_1.default.heapConfig.isCliInteractiveMode &&
+        Config_1.default.heapConfig.currentHeapFile) {
+        path = Config_1.default.heapConfig.currentHeapFile;
+        // search for snapshot labeled as baseline, target, or final
+    }
+    else {
+        path = getSnapshotFilePathWithTabType(/(final)|(target)|(baseline)/);
+    }
     return resolveSnapshotFilePath(path);
 }
 function getSnapshotFilePath(tab) {
@@ -1286,7 +1302,7 @@ function getSnapshotFilePath(tab) {
     }
     return Config_1.default.externalSnapshotFilePaths[tab.idx - 1];
 }
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function equalOrMatch(v1, v2) {
     const t1 = typeof v1;
     const t2 = typeof v2;
@@ -1421,7 +1437,6 @@ function isURLEqual(url1, url2) {
     try {
         u1 = new URL(url1);
         u2 = new URL(url2);
-        // eslint-disable-next-line fb-www/no-unused-catch-bindings
     }
     catch (_e) {
         return false;

package/dist/lib/heap-data/HeapSnapshot.d.ts

@@ -12,6 +12,7 @@ import type { IHeapNode, IHeapNodes, IHeapEdges, IHeapSnapshot, HeapNodeTypes, H
 import HeapNode from './HeapNode';
 export default class HeapSnapshot implements IHeapSnapshot {
     snapshot: RawHeapSnapshot;
+    isProcessed: boolean;
     nodes: IHeapNodes;
     _nodeCount: number;
     edges: IHeapEdges;