@memlab/heap-analysis 1.0.0 → 1.0.3

package/dist/PluginUtils.js

@@ -51,9 +51,13 @@ function isNodeWorthInspecting(node) {
     }
     return true;
 }
-// filter out dominators that have a similar size
-// for example if input is [A, B] and A is the dominator of B
-// then this function throw away A if the size of A is close to the size of B
+/**
+ * filter out dominators that have a similar size, for example if
+ * input is [A, B] and A is the dominator of B, then this function
+ * throw away A if the size of A is close to the size of B
+ * @param nodeList an array of heap nodes
+ * @returns an array of heap nodes with dominators that have similar size removed
+ */
 function filterOutDominators(nodeList) {
     const candidateIdSet = new Set(nodeList.map(node => node.id));
     const childrenSizeInList = new Map();
@@ -182,6 +186,46 @@ function getObjectOutgoingEdgeCount(node) {
     }
     return node.edge_count;
 }
+/**
+ * Get the heap snapshot file's absolute path passed to the hosting heap
+ * analysis via `HeapAnalysisOptions`.
+ *
+ * This API is supposed to be used within the overridden `process` method
+ * of an `BaseAnalysis` instance.
+ *
+ * @param options this is the auto-generated input passed to all the `BaseAnalysis` instances
+ * @returns the absolute path of the heap snapshot file
+ * * **Examples:**
+ * ```typescript
+ * import type {IHeapSnapshot} from '@memlab/core';
+ * import type {HeapAnalysisOptions} from '@memlab/heap-analysis';
+ * import {getSnapshotFileForAnalysis, BaseAnalysis} from '@memlab/heap-analysis';
+ *
+ * class ExampleAnalysis extends BaseAnalysis {
+ *   public getCommandName(): string {
+ *     return 'example-analysis';
+ *   }
+ *
+ *   public getDescription(): string {
+ *     return 'an example analysis for demo';
+ *   }
+ *
+ *   async process(options: HeapAnalysisOptions): Promise<void> {
+ *     const file = getSnapshotFileForAnalysis(options);
+ *   }
+ * }
+ * ```
+ *
+ * Use the following code to invoke the heap analysis:
+ * ```typescript
+ * const analysis = new ExampleAnalysis();
+ * // any .heapsnapshot file recorded by memlab or saved manually from Chrome
+ * await analysis.analyzeSnapshotFromFile(snapshotFile);
+ * ```
+ * The new heap analysis can also be used with {@link analyze}, in that case
+ * `getSnapshotFileForAnalysis` will use the last heap snapshot in alphanumerically
+ * ascending order from {@link BrowserInteractionResultReader}.
+ */
 function getSnapshotFileForAnalysis(options) {
     const args = options.args;
     if (args.snapshot) {
@@ -192,6 +236,47 @@ function getSnapshotFileForAnalysis(options) {
     }
     return core_2.utils.getSingleSnapshotFileForAnalysis();
 }
+/**
+ * Get the absolute path of the directory holding all the heap snapshot files
+ * passed to the hosting heap analysis via `HeapAnalysisOptions`.
+ *
+ * This API is supposed to be used within the overridden `process` method
+ * of an `BaseAnalysis` instance.
+ *
+ * @param options this is the auto-generated input passed
+ * to all the `BaseAnalysis` instances
+ * @returns the absolute path of the directory
+ * * **Examples:**
+ * ```typescript
+ * import type {IHeapSnapshot} from '@memlab/core';
+ * import type {HeapAnalysisOptions} from '@memlab/heap-analysis';
+ * import {getSnapshotFileForAnalysis, BaseAnalysis} from '@memlab/heap-analysis';
+ *
+ * class ExampleAnalysis extends BaseAnalysis {
+ *   public getCommandName(): string {
+ *     return 'example-analysis';
+ *   }
+ *
+ *   public getDescription(): string {
+ *     return 'an example analysis for demo';
+ *   }
+ *
+ *   async process(options: HeapAnalysisOptions): Promise<void> {
+ *     const directory = getSnapshotDirForAnalysis(options);
+ *   }
+ * }
+ * ```
+ *
+ * Use the following code to invoke the heap analysis:
+ * ```typescript
+ * const analysis = new ExampleAnalysis();
+ * // any .heapsnapshot file recorded by memlab or saved manually from Chrome
+ * await analysis.analyzeSnapshotFromFile(snapshotFile);
+ * ```
+ * The new heap analysis can also be used with {@link analyze}, in that case
+ * `getSnapshotDirForAnalysis` use the snapshot directory from
+ * {@link BrowserInteractionResultReader}.
+ */
 function getSnapshotDirForAnalysis(options) {
     const args = options.args;
     if (args['snapshot-dir']) {
@@ -202,21 +287,147 @@ function getSnapshotDirForAnalysis(options) {
     }
     return null;
 }
+/**
+ * Load the heap graph based on the single JavaScript heap snapshot
+ * passed to the hosting heap analysis via `HeapAnalysisOptions`.
+ *
+ * This API is supposed to be used within the `process` implementation
+ * of an `BaseAnalysis` instance.
+ *
+ * @param options this is the auto-generated input passed to all the `BaseAnalysis` instances
+ * @returns the graph representation of the heap
+ * * **Examples:**
+ * ```typescript
+ * import type {IHeapSnapshot} from '@memlab/core';
+ * import type {HeapAnalysisOptions} from '@memlab/heap-analysis';
+ * import {loadHeapSnapshot, BaseAnalysis} from '@memlab/heap-analysis';
+ *
+ * class ExampleAnalysis extends BaseAnalysis {
+ *   public getCommandName(): string {
+ *     return 'example-analysis';
+ *   }
+ *
+ *   public getDescription(): string {
+ *     return 'an example analysis for demo';
+ *   }
+ *
+ *   async process(options: HeapAnalysisOptions): Promise<void> {
+ *     const heap = await loadHeapSnapshot(options);
+ *     // doing heap analysis
+ *   }
+ * }
+ * ```
+ *
+ * Use the following code to invoke the heap analysis:
+ * ```typescript
+ * const analysis = new ExampleAnalysis();
+ * // any .heapsnapshot file recorded by memlab or saved manually from Chrome
+ * await analysis.analyzeSnapshotFromFile(snapshotFile);
+ * ```
+ * The new heap analysis can also be used with {@link analyze}, in that case
+ * `loadHeapSnapshot` will use the last heap snapshot in alphanumerically
+ * ascending order from {@link BrowserInteractionResultReader}.
+ */
 function loadHeapSnapshot(options) {
     return __awaiter(this, void 0, void 0, function* () {
         const file = getSnapshotFileForAnalysis(options);
         return loadProcessedSnapshot({ file });
     });
 }
+/**
+ * Load and parse a `.heapsnapshot` file and calculate meta data like
+ * dominator nodes and retained sizes.
+ * @param file the absolute path of the `.heapsnapshot` file
+ * @returns the heap graph representation instance that supports querying
+ * the heap
+ * * **Examples**:
+ * ```typescript
+ * import {dumpNodeHeapSnapshot} from '@memlab/core';
+ * import {getHeapFromFile} from '@memlab/heap-analysis';
+ *
+ * (async function (){
+ *   const heapFile = dumpNodeHeapSnapshot();
+ *   const heap = await getHeapFromFile(heapFile);
+ * })();
+ * ```
+ */
+function getHeapFromFile(file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield loadProcessedSnapshot({ file });
+    });
+}
 function loadProcessedSnapshot(options = {}) {
     return __awaiter(this, void 0, void 0, function* () {
         const opt = { buildNodeIdIndex: true, verbose: true };
         const file = options.file || core_2.utils.getSnapshotFilePathWithTabType(/.*/);
         const snapshot = yield core_2.utils.getSnapshotFromFile(file, opt);
         core_2.analysis.preparePathFinder(snapshot);
+        core_2.info.flush();
         return snapshot;
     });
 }
+/**
+ * When a heap analysis is taking multiple heap snapshots as input for memory
+ * analysis (e.g., finding which object keeps growing in size in a series of
+ * heap snapshots), this API could be used to do
+ * [MapRedue](https://en.wikipedia.org/wiki/MapReduce) on all heap snapshots.
+ *
+ * This API is supposed to be used within the `process` implementation
+ * of an `BaseAnalysis` instance that is designed to analyze multiple heap
+ * snapshots (as an example, finding which object keeps growing overtime)
+ *
+ * @param mapCallback the map function in MapReduce, the function will be applied
+ * to each heap snapshot
+ * @param reduceCallback the reduce function in MapReduce, the function will take
+ * as input all intermediate results from all map function calls
+ * @typeParam T1 - the type of the intermediate result from each map function call
+ * @typeParam T2 - the type of the final result of the reduce function call
+ * @param options this is the auto-generated input passed to all the `BaseAnalysis` instances
+ * @returns the return value of your reduce function
+ * * **Examples:**
+ * ```typescript
+ * import type {IHeapSnapshot} from '@memlab/core';
+ * import type {HeapAnalysisOptions} from '@memlab/heap-analysis';
+ * import {snapshotMapReduce, BaseAnalysis} from '@memlab/heap-analysis';
+ *
+ * class ExampleAnalysis extends BaseAnalysis {
+ *   public getCommandName(): string {
+ *     return 'example-analysis';
+ *   }
+ *
+ *   public getDescription(): string {
+ *     return 'an example analysis for demo';
+ *   }
+ *
+ *   async process(options: HeapAnalysisOptions): Promise<void> {
+ *     // check if the number of heap objects keeps growing overtime
+ *     const isMonotonicIncreasing = await snapshotMapReduce(
+ *       (heap) => heap.nodes.length,
+ *       (nodeCounts) =>
+ *         nodeCounts[0] < nodeCounts[nodeCounts.length - 1] &&
+ *         nodeCounts.every((count, i) => i === 0 || count >= nodeCounts[i - 1]),
+ *       options,
+ *     );
+ *   }
+ * }
+ * ```
+ *
+ * Use the following code to invoke the heap analysis:
+ * ```typescript
+ * const analysis = new ExampleAnalysis();
+ * // snapshotDir includes a series of .heapsnapshot files recorded by
+ * // memlab or saved manually from Chrome, those files will be loaded
+ * // in alphanumerically asceneding order
+ * await analysis.analyzeSnapshotsInDirectory(snapshotDir);
+ * ```
+ * The new heap analysis can also be used with {@link analyze}, in that case
+ * `snapshotMapReduce` will use all the heap snapshot in alphanumerically
+ * ascending order from {@link BrowserInteractionResultReader}.
+ *
+ * **Why not passing in all heap snapshots as an array of {@link IHeapSnapshot}s?**
+ * Each heap snapshot could be non-trivial in size, loading them all at once
+ * may not be possible.
+ */
 function snapshotMapReduce(mapCallback, reduceCallback, options) {
     return __awaiter(this, void 0, void 0, function* () {
         const snapshotDir = getSnapshotDirForAnalysis(options);
@@ -239,6 +450,18 @@ function snapshotMapReduce(mapCallback, reduceCallback, options) {
         return reduceCallback(intermediateResults);
     });
 }
+/**
+ * This API aggregates metrics from the
+ * [dominator nodes](https://firefox-source-docs.mozilla.org/devtools-user/memory/dominators/index.html)
+ * of the set of input heap objects.
+ *
+ * @param ids Set of ids of heap objects (or nodes)
+ * @param snapshot heap graph loaded from a heap snapshot
+ * @param checkNodeCb filter callback to exclude some heap object/nodes
+ * before calculating the dominator nodes
+ * @param nodeMetricsCb callback to calculate metrics from each dominator node
+ * @returns the aggregated metrics
+ */
 function aggregateDominatorMetrics(ids, snapshot, checkNodeCb, nodeMetricsCb) {
     let ret = 0;
     const dominators = core_2.utils.getConditionalDominatorIds(ids, snapshot, checkNodeCb);
@@ -247,6 +470,47 @@ function aggregateDominatorMetrics(ids, snapshot, checkNodeCb, nodeMetricsCb) {
     });
     return ret;
 }
+/**
+ * This API calculate the set of
+ * [dominator nodes](https://firefox-source-docs.mozilla.org/devtools-user/memory/dominators/index.html)
+ * of the set of input heap objects.
+ * @param ids Set of ids of heap objects (or nodes)
+ * @param snapshot heap loaded from a heap snapshot
+ * @returns the set of dominator nodes/objects
+ * * * **Examples**:
+ * ```typescript
+ * import {dumpNodeHeapSnapshot} from '@memlab/core';
+ * import {getHeapFromFile, getDominatorNodes} from '@memlab/heap-analysis';
+ *
+ * class TestObject {}
+ *
+ * (async function () {
+ *   const t1 = new TestObject();
+ *   const t2 = new TestObject();
+ *
+ *   // dump the heap of this running JavaScript program
+ *   const heapFile = dumpNodeHeapSnapshot();
+ *   const heap = await getHeapFromFile(heapFile);
+ *
+ *   // find the heap node for TestObject
+ *   let nodes = [];
+ *   heap.nodes.forEach(node => {
+ *     if (node.name === 'TestObject' && node.type === 'object') {
+ *       nodes.push(node);
+ *     }
+ *   });
+ *
+ *   // get the dominator nodes
+ *   const dominatorIds = getDominatorNodes(
+ *     new Set(nodes.map(node => node.id)),
+ *     heap,
+ *   );
+ * })();
+ * ```
+ */
+function getDominatorNodes(ids, snapshot) {
+    return core_2.utils.getConditionalDominatorIds(ids, snapshot, () => true);
+}
 function filterOutLargestObjects(snapshot, objectFilter, listSize = 50) {
     let largeObjects = [];
     snapshot.nodes.forEach(node => {
@@ -272,11 +536,13 @@ exports.default = {
     aggregateDominatorMetrics,
     defaultAnalysisArgs,
     filterOutLargestObjects,
+    getDominatorNodes,
     getObjectOutgoingEdgeCount,
     getSnapshotDirForAnalysis,
     getSnapshotFileForAnalysis,
     isNodeWorthInspecting,
     loadHeapSnapshot,
+    getHeapFromFile,
     printNodeListInTerminal,
     printReferencesInTerminal,
     snapshotMapReduce,

package/dist/__tests__/package.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=package.test.d.ts.map

package/dist/__tests__/package.test.js

@@ -0,0 +1,85 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@memlab/core");
+const index_1 = require("../index");
+beforeEach(() => {
+    core_1.config.isTest = true;
+});
+test('loadHeapSnapshot works as expected', () => __awaiter(void 0, void 0, void 0, function* () {
+    let called = false;
+    class ExampleAnalysis extends index_1.BaseAnalysis {
+        getCommandName() {
+            return 'example-analysis';
+        }
+        getDescription() {
+            return 'an example analysis for demo';
+        }
+        process(options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const heap = yield (0, index_1.loadHeapSnapshot)(options);
+                called = true;
+                expect(heap.nodes.length > 0).toBe(true);
+            });
+        }
+    }
+    const analysis = new ExampleAnalysis();
+    yield analysis.analyzeSnapshotFromFile((0, core_1.dumpNodeHeapSnapshot)());
+    expect(called).toBe(true);
+}));
+test('analyzeSnapshotFromFile works as expected', () => __awaiter(void 0, void 0, void 0, function* () {
+    let called = false;
+    const heapFile = (0, core_1.dumpNodeHeapSnapshot)();
+    class ExampleAnalysis extends index_1.BaseAnalysis {
+        getCommandName() {
+            return 'example-analysis';
+        }
+        getDescription() {
+            return 'an example analysis for demo';
+        }
+        process(options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const file = (0, index_1.getSnapshotFileForAnalysis)(options);
+                called = true;
+                expect(file).toBe(heapFile);
+            });
+        }
+    }
+    const analysis = new ExampleAnalysis();
+    yield analysis.analyzeSnapshotFromFile(heapFile);
+    expect(called).toBe(true);
+}));
+test('getHeapFromFile works as expected', () => __awaiter(void 0, void 0, void 0, function* () {
+    const heapFile = (0, core_1.dumpNodeHeapSnapshot)();
+    const heap = yield (0, index_1.getHeapFromFile)(heapFile);
+    expect(heap.nodes.length > 0).toBe(true);
+}));
+test('getDominatorNodes works as expected', () => __awaiter(void 0, void 0, void 0, function* () {
+    class TestObject {
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const t1 = new TestObject();
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const t2 = new TestObject();
+    // dump the heap of this running JavaScript program
+    const heapFile = (0, core_1.dumpNodeHeapSnapshot)();
+    const heap = yield (0, index_1.getHeapFromFile)(heapFile);
+    // find the heap node for TestObject
+    const nodes = [];
+    heap.nodes.forEach(node => {
+        if (node.name === 'TestObject' && node.type === 'object') {
+            nodes.push(node);
+        }
+    });
+    // get the dominator nodes
+    const dominatorIds = (0, index_1.getDominatorNodes)(new Set(nodes.map(node => node.id)), heap);
+    expect(dominatorIds.size).toBeGreaterThan(0);
+}));

package/dist/index.d.ts

@@ -7,7 +7,8 @@
  * @emails oncall+ws_labs
  * @format
  */
-export { default as heapAnalysisLoader } from './HeapAnalysisLoader';
+export declare const getDominatorNodes: (ids: Set<number>, snapshot: import("../../core/src").IHeapSnapshot) => Set<number>, getHeapFromFile: (file: string) => Promise<import("../../core/src").IHeapSnapshot>, getSnapshotDirForAnalysis: (options: import("./PluginUtils").HeapAnalysisOptions) => import("../../core/src").Nullable<string>, getSnapshotFileForAnalysis: (options: import("./PluginUtils").HeapAnalysisOptions) => string, loadHeapSnapshot: (options: import("./PluginUtils").HeapAnalysisOptions) => Promise<import("../../core/src").IHeapSnapshot>, snapshotMapReduce: <T1, T2>(mapCallback: (snapshot: import("../../core/src").IHeapSnapshot, i: number, file: string) => T1, reduceCallback: (results: T1[]) => T2, options: import("./PluginUtils").HeapAnalysisOptions) => Promise<T2>;
+export type { HeapAnalysisOptions } from './PluginUtils';
 export { default as BaseAnalysis } from './BaseAnalysis';
 export { default as DetachedDOMElementAnalysis } from './plugins/DetachedDOMElementAnalysis';
 export { default as GlobalVariableAnalysis } from './plugins/GlobalVariableAnalysis/GlobalVariableAnalysis';
@@ -19,5 +20,8 @@ export { default as ObjectFanoutAnalysis } from './plugins/ObjectFanoutAnalysis'
 export { default as ObjectShapeAnalysis } from './plugins/ObjectShapeAnalysis';
 export { default as ObjectUnboundGrowthAnalysis } from './plugins/ObjectUnboundGrowthAnalysis';
 export { default as StringAnalysis } from './plugins/StringAnalysis';
+/** @internal */
 export { default as PluginUtils } from './PluginUtils';
+/** @internal */
+export { default as heapAnalysisLoader } from './HeapAnalysisLoader';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -12,9 +12,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginUtils = exports.StringAnalysis = exports.ObjectUnboundGrowthAnalysis = exports.ObjectShapeAnalysis = exports.ObjectFanoutAnalysis = exports.ShapeUnboundGrowthAnalysis = exports.ObjectSizeAnalysis = exports.ObjectShallowAnalysis = exports.CollectionsHoldingStaleAnalysis = exports.GlobalVariableAnalysis = exports.DetachedDOMElementAnalysis = exports.BaseAnalysis = exports.heapAnalysisLoader = void 0;
-var HeapAnalysisLoader_1 = require("./HeapAnalysisLoader");
-Object.defineProperty(exports, "heapAnalysisLoader", { enumerable: true, get: function () { return __importDefault(HeapAnalysisLoader_1).default; } });
+exports.heapAnalysisLoader = exports.PluginUtils = exports.StringAnalysis = exports.ObjectUnboundGrowthAnalysis = exports.ObjectShapeAnalysis = exports.ObjectFanoutAnalysis = exports.ShapeUnboundGrowthAnalysis = exports.ObjectSizeAnalysis = exports.ObjectShallowAnalysis = exports.CollectionsHoldingStaleAnalysis = exports.GlobalVariableAnalysis = exports.DetachedDOMElementAnalysis = exports.BaseAnalysis = exports.snapshotMapReduce = exports.loadHeapSnapshot = exports.getSnapshotFileForAnalysis = exports.getSnapshotDirForAnalysis = exports.getHeapFromFile = exports.getDominatorNodes = void 0;
+const PluginUtils_1 = __importDefault(require("./PluginUtils"));
+exports.getDominatorNodes = PluginUtils_1.default.getDominatorNodes, exports.getHeapFromFile = PluginUtils_1.default.getHeapFromFile, exports.getSnapshotDirForAnalysis = PluginUtils_1.default.getSnapshotDirForAnalysis, exports.getSnapshotFileForAnalysis = PluginUtils_1.default.getSnapshotFileForAnalysis, exports.loadHeapSnapshot = PluginUtils_1.default.loadHeapSnapshot, exports.snapshotMapReduce = PluginUtils_1.default.snapshotMapReduce;
 var BaseAnalysis_1 = require("./BaseAnalysis");
 Object.defineProperty(exports, "BaseAnalysis", { enumerable: true, get: function () { return __importDefault(BaseAnalysis_1).default; } });
 var DetachedDOMElementAnalysis_1 = require("./plugins/DetachedDOMElementAnalysis");
@@ -37,5 +37,9 @@ var ObjectUnboundGrowthAnalysis_1 = require("./plugins/ObjectUnboundGrowthAnalys
 Object.defineProperty(exports, "ObjectUnboundGrowthAnalysis", { enumerable: true, get: function () { return __importDefault(ObjectUnboundGrowthAnalysis_1).default; } });
 var StringAnalysis_1 = require("./plugins/StringAnalysis");
 Object.defineProperty(exports, "StringAnalysis", { enumerable: true, get: function () { return __importDefault(StringAnalysis_1).default; } });
-var PluginUtils_1 = require("./PluginUtils");
-Object.defineProperty(exports, "PluginUtils", { enumerable: true, get: function () { return __importDefault(PluginUtils_1).default; } });
+/** @internal */
+var PluginUtils_2 = require("./PluginUtils");
+Object.defineProperty(exports, "PluginUtils", { enumerable: true, get: function () { return __importDefault(PluginUtils_2).default; } });
+/** @internal */
+var HeapAnalysisLoader_1 = require("./HeapAnalysisLoader");
+Object.defineProperty(exports, "heapAnalysisLoader", { enumerable: true, get: function () { return __importDefault(HeapAnalysisLoader_1).default; } });

package/dist/plugins/CollectionsHoldingStaleAnalysis.d.ts

@@ -12,9 +12,14 @@ import { BaseOption } from '@memlab/core';
 import BaseAnalysis from '../BaseAnalysis';
 export default class CollectionsHoldingStaleAnalysis extends BaseAnalysis {
     getCommandName(): string;
+    /** @internal */
     getDescription(): string;
+    /** @internal */
     getOptions(): BaseOption[];
+    /** @internal */
+    analyzeSnapshotsInDirectory(directory: string): Promise<void>;
     private staleCollectionMapper;
+    /** @internal */
     process(options: HeapAnalysisOptions): Promise<void>;
     private getCollectionsWithStaleValues;
     private print;

package/dist/plugins/CollectionsHoldingStaleAnalysis.js

@@ -69,12 +69,23 @@ class CollectionsHoldingStaleAnalysis extends BaseAnalysis_1.default {
     getCommandName() {
         return 'collections-with-stale';
     }
+    /** @internal */
     getDescription() {
         return 'Analyze collections holding stale objects';
     }
+    /** @internal */
     getOptions() {
         return [new HeapAnalysisSnapshotFileOption_1.default()];
     }
+    /** @internal */
+    analyzeSnapshotsInDirectory(directory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const d = directory;
+            throw core_1.utils.haltOrThrow(`${this.constructor.name} does not support analyzeSnapshotsInDirectory`);
+        });
+    }
+    /** @internal */
     process(options) {
         return __awaiter(this, void 0, void 0, function* () {
             const snapshot = yield PluginUtils_1.default.loadHeapSnapshot(options);

package/dist/plugins/DetachedDOMElementAnalysis.d.ts

@@ -13,10 +13,15 @@ import { BaseOption } from '@memlab/core';
 import BaseAnalysis from '../BaseAnalysis';
 export default class DetachedDOMElementAnalysis extends BaseAnalysis {
     getCommandName(): string;
+    /** @internal */
     getDescription(): string;
+    /** @internal */
     getOptions(): BaseOption[];
+    /** @internal */
+    analyzeSnapshotsInDirectory(directory: string): Promise<void>;
     private detachedElements;
     getDetachedElements(): IHeapNode[];
+    /** @internal */
     process(options: HeapAnalysisOptions): Promise<void>;
 }
 //# sourceMappingURL=DetachedDOMElementAnalysis.d.ts.map

package/dist/plugins/DetachedDOMElementAnalysis.js

@@ -33,15 +33,26 @@ class DetachedDOMElementAnalysis extends BaseAnalysis_1.default {
     getCommandName() {
         return 'detached-DOM';
     }
+    /** @internal */
     getDescription() {
         return 'Get detached DOM elements';
     }
+    /** @internal */
     getOptions() {
         return [new HeapAnalysisSnapshotFileOption_1.default()];
     }
+    /** @internal */
+    analyzeSnapshotsInDirectory(directory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const d = directory;
+            throw core_1.utils.haltOrThrow(`${this.constructor.name} does not support analyzeSnapshotsInDirectory`);
+        });
+    }
     getDetachedElements() {
         return this.detachedElements;
     }
+    /** @internal */
     process(options) {
         return __awaiter(this, void 0, void 0, function* () {
             const snapshot = yield PluginUtils_1.default.loadHeapSnapshot(options);

package/dist/plugins/GlobalVariableAnalysis/GlobalVariableAnalysis.d.ts

@@ -12,10 +12,16 @@ import { BaseOption } from '@memlab/core';
 import BaseAnalysis from '../../BaseAnalysis';
 declare class GlobalVariableAnalysis extends BaseAnalysis {
     getCommandName(): string;
+    /** @internal */
     getDescription(): string;
+    /** @internal */
     getOptions(): BaseOption[];
+    /** @internal */
     process(options: HeapAnalysisOptions): Promise<void>;
+    /** @internal */
+    analyzeSnapshotsInDirectory(directory: string): Promise<void>;
     private shouldFilterOutEdge;
+    /** @internal */
     private getGlobalVariables;
 }
 export default GlobalVariableAnalysis;

package/dist/plugins/GlobalVariableAnalysis/GlobalVariableAnalysis.js

@@ -21,6 +21,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@memlab/core");
 const HeapAnalysisSnapshotFileOption_1 = __importDefault(require("../../options/HeapAnalysisSnapshotFileOption"));
 const BaseAnalysis_1 = __importDefault(require("../../BaseAnalysis"));
 const PluginUtils_1 = __importDefault(require("../../PluginUtils"));
@@ -29,12 +30,15 @@ class GlobalVariableAnalysis extends BaseAnalysis_1.default {
     getCommandName() {
         return 'global-variable';
     }
+    /** @internal */
     getDescription() {
         return 'Get global variables in heap';
     }
+    /** @internal */
     getOptions() {
         return [new HeapAnalysisSnapshotFileOption_1.default()];
     }
+    /** @internal */
     process(options) {
         return __awaiter(this, void 0, void 0, function* () {
             const snapshot = yield PluginUtils_1.default.loadHeapSnapshot(options);
@@ -42,6 +46,14 @@ class GlobalVariableAnalysis extends BaseAnalysis_1.default {
             PluginUtils_1.default.printReferencesInTerminal(list);
         });
     }
+    /** @internal */
+    analyzeSnapshotsInDirectory(directory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const d = directory;
+            throw core_1.utils.haltOrThrow(`${this.constructor.name} does not support analyzeSnapshotsInDirectory`);
+        });
+    }
     shouldFilterOutEdge(edge) {
         if (BuiltInGlobalVariables_1.default.has(`${edge.name_or_index}`)) {
             return true;
@@ -57,6 +69,7 @@ class GlobalVariableAnalysis extends BaseAnalysis_1.default {
         }
         return false;
     }
+    /** @internal */
     getGlobalVariables(snapshot) {
         // rank heap objects based on fanout
         const ret = [];

package/dist/plugins/ObjectFanoutAnalysis.d.ts

@@ -12,8 +12,13 @@ import { BaseOption } from '@memlab/core';
 import BaseAnalysis from '../BaseAnalysis';
 declare class ObjectFanoutAnalysis extends BaseAnalysis {
     getCommandName(): string;
+    /** @internal */
     getDescription(): string;
+    /** @internal */
     getOptions(): BaseOption[];
+    /** @internal */
+    analyzeSnapshotsInDirectory(directory: string): Promise<void>;
+    /** @internal */
     process(options: HeapAnalysisOptions): Promise<void>;
     private getObjectsWithHighFanout;
 }

package/dist/plugins/ObjectFanoutAnalysis.js

@@ -21,6 +21,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@memlab/core");
 const BaseAnalysis_1 = __importDefault(require("../BaseAnalysis"));
 const PluginUtils_1 = __importDefault(require("../PluginUtils"));
 const HeapAnalysisSnapshotFileOption_1 = __importDefault(require("../options/HeapAnalysisSnapshotFileOption"));
@@ -28,12 +29,23 @@ class ObjectFanoutAnalysis extends BaseAnalysis_1.default {
     getCommandName() {
         return 'object-fanout';
     }
+    /** @internal */
     getDescription() {
         return 'Get objects with the most out-going references in heap';
     }
+    /** @internal */
     getOptions() {
         return [new HeapAnalysisSnapshotFileOption_1.default()];
     }
+    /** @internal */
+    analyzeSnapshotsInDirectory(directory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const d = directory;
+            throw core_1.utils.haltOrThrow(`${this.constructor.name} does not support analyzeSnapshotsInDirectory`);
+        });
+    }
+    /** @internal */
     process(options) {
         return __awaiter(this, void 0, void 0, function* () {
             const snapshot = yield PluginUtils_1.default.loadHeapSnapshot(options);