@memlab/core 1.1.6 → 1.1.7

package/dist/__tests__/parser/HeapParser.test.js

@@ -36,7 +36,7 @@ test('Capture inserted object', () => __awaiter(void 0, void 0, void 0, function
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const injected = new TestObject();
-    const heap = yield (0, NodeHeap_1.getNodeInnocentHeap)();
+    const heap = yield (0, NodeHeap_1.takeNodeMinimalHeap)();
     expect(heap.hasObjectWithClassName('TestObject')).toBe(true);
 }), timeout);
 test('Does not capture transcient object', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -49,6 +49,6 @@ test('Does not capture transcient object', () => __awaiter(void 0, void 0, void
     let injected = new TestObject();
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     injected = null;
-    const heap = yield (0, NodeHeap_1.getNodeInnocentHeap)();
+    const heap = yield (0, NodeHeap_1.takeNodeMinimalHeap)();
     expect(heap.hasObjectWithClassName('TestObject')).toBe(false);
 }), timeout);

package/dist/__tests__/parser/NodeHeap.test.js

@@ -30,7 +30,7 @@ const timeout = 5 * 60 * 1000;
 test('Capture current node heap snapshot', () => __awaiter(void 0, void 0, void 0, function* () {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const object = { 'memlab-test-heap-property': 'memlab-test-heap-value' };
-    const heap = yield (0, NodeHeap_1.getNodeInnocentHeap)();
+    const heap = yield (0, NodeHeap_1.takeNodeMinimalHeap)();
     expect(heap.hasObjectWithPropertyName('memlab-test-heap-property')).toBe(true);
 }), timeout);
 test('Nullified Object should not exist in heap', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -39,7 +39,7 @@ test('Nullified Object should not exist in heap', () => __awaiter(void 0, void 0
     };
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     object = null;
-    const heap = yield (0, NodeHeap_1.getNodeInnocentHeap)();
+    const heap = yield (0, NodeHeap_1.takeNodeMinimalHeap)();
     expect(heap.hasObjectWithPropertyName('memlab-test-heap-property')).toBe(false);
 }), timeout);
 test('Strongly referenced object should exist in heap', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -59,7 +59,7 @@ test('Strongly referenced object should exist in heap', () => __awaiter(void 0,
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const object = buildTest();
-    const heap = yield (0, NodeHeap_1.getNodeInnocentHeap)();
+    const heap = yield (0, NodeHeap_1.takeNodeMinimalHeap)();
     expect(heap.hasObjectWithClassName('TestClass1')).toBe(true);
     expect(heap.hasObjectWithClassName('TestClass2')).toBe(true);
 }), timeout);
@@ -80,7 +80,7 @@ test('Weakly referenced object should not exist in heap', () => __awaiter(void 0
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const object = buildTest();
-    const heap = yield (0, NodeHeap_1.getNodeInnocentHeap)();
+    const heap = yield (0, NodeHeap_1.takeNodeMinimalHeap)();
     expect(heap.hasObjectWithClassName('TestClass3')).toBe(true);
     expect(heap.hasObjectWithClassName('TestClass4')).toBe(false);
 }), timeout);
@@ -90,7 +90,7 @@ test('Check annotated objects', () => __awaiter(void 0, void 0, void 0, function
     (0, NodeHeap_1.tagObject)(o1, 'memlab-mark-1');
     (0, NodeHeap_1.tagObject)(o2, 'memlab-mark-2');
     o2 = null;
-    const heap = yield (0, NodeHeap_1.getNodeInnocentHeap)();
+    const heap = yield (0, NodeHeap_1.takeNodeMinimalHeap)();
     expect(heap.hasObjectWithTag('memlab-mark-1')).toBe(true);
     expect(heap.hasObjectWithTag('memlab-mark-2')).toBe(false);
 }), timeout);

package/dist/__tests__/parser/StringNode.test.js

@@ -41,7 +41,7 @@ test('String heap object APIs work', () => __awaiter(void 0, void 0, void 0, fun
     injected.complexConcatString += 'value_';
     injected.complexConcatString += 123;
     injected.complexConcatString += '_suffix';
-    const heap = yield (0, NodeHeap_1.getNodeInnocentHeap)();
+    const heap = yield (0, NodeHeap_1.takeNodeMinimalHeap)();
     const testObject = heap.getAnyObjectWithClassName('TestObject');
     expect(testObject).not.toBe(null);
     // testObject.originalString === 'test'

package/dist/__tests__/parser/traverse/HeapNodeTraverse.test.js

@@ -74,7 +74,7 @@ test('Check getReference and getReferenceNode', () => __awaiter(void 0, void 0,
         });
         return detected;
     };
-    const heap = yield (0, NodeHeap_1.getNodeInnocentHeap)();
+    const heap = yield (0, NodeHeap_1.takeNodeMinimalHeap)();
     expect(checker(heap)).toBe(true);
 }), timeout);
 test('Check getReferrers and getReferrerNodes', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -135,6 +135,6 @@ test('Check getReferrers and getReferrerNodes', () => __awaiter(void 0, void 0,
         }
         return true;
     };
-    const heap = yield (0, NodeHeap_1.getNodeInnocentHeap)();
+    const heap = yield (0, NodeHeap_1.takeNodeMinimalHeap)();
     expect(checker(heap)).toBe(true);
 }), timeout);

package/dist/index.d.ts

@@ -10,6 +10,7 @@
 /** @internal */
 export declare function registerPackage(): Promise<void>;
 export * from './lib/Types';
+export * from './lib/NodeHeap';
 /** @internal */
 export { default as config } from './lib/Config';
 /** @internal */
@@ -46,5 +47,4 @@ export { default as NormalizedTrace } from './trace-cluster/TraceBucket';
 export { default as EvaluationMetric } from './trace-cluster/EvalutationMetric';
 /** @internal */
 export * from './lib/PackageInfoLoader';
-export * from './lib/NodeHeap';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -46,6 +46,7 @@ function registerPackage() {
 }
 exports.registerPackage = registerPackage;
 __exportStar(require("./lib/Types"), exports);
+__exportStar(require("./lib/NodeHeap"), exports);
 /** @internal */
 var Config_1 = require("./lib/Config");
 Object.defineProperty(exports, "config", { enumerable: true, get: function () { return __importDefault(Config_1).default; } });
@@ -96,4 +97,3 @@ var EvalutationMetric_1 = require("./trace-cluster/EvalutationMetric");
 Object.defineProperty(exports, "EvaluationMetric", { enumerable: true, get: function () { return __importDefault(EvalutationMetric_1).default; } });
 /** @internal */
 __exportStar(require("./lib/PackageInfoLoader"), exports);
-__exportStar(require("./lib/NodeHeap"), exports);

package/dist/lib/Config.d.ts

@@ -9,6 +9,7 @@
  */
 import type { LaunchOptions, Permission } from 'puppeteer';
 import type { AnyFunction, AnyValue, IClusterStrategy, IRunningMode, IScenario, Nullable, Optional, QuickExperiment, ILeakFilter, IPackageInfo } from './Types';
+import { IHeapConfig } from '..';
 interface BrowserLaunchArgumentOptions {
     headless?: boolean;
     userDataDir?: string;
@@ -95,6 +96,7 @@ export declare class MemLabConfig {
     dataBuilderDataDir: string;
     unclassifiedClusterDir: string;
     externalCookiesFile: Optional<string>;
+    heapConfig: Optional<IHeapConfig>;
     puppeteerConfig: LaunchOptions & BrowserLaunchArgumentOptions & BrowserConnectOptions;
     openDevtoolsConsole: boolean;
     emulateDevice: Nullable<Device>;
@@ -182,6 +184,7 @@ export declare class MemLabConfig {
     packageInfo: IPackageInfo[];
     isMLClustering: boolean;
     mlClusteringLinkageMaxDistance: number;
+    mlMaxDF: number;
     constructor(options?: ConfigOption);
     private initInternalConfigs;
     private init;

package/dist/lib/Config.js

@@ -65,6 +65,8 @@ class MemLabConfig {
         // by default we want to use Xvfb if the Env supports it
         this.useXVFB = true;
         this.specifiedEngine = false;
+        // set by the heap-analysis package if HeapConfig is used
+        this.heapConfig = null;
         // set puppeteer configuration
         this.puppeteerConfig = {
             headless: !this._isHeadfulBrowser,
@@ -126,7 +128,12 @@ class MemLabConfig {
         this.includeObjectInfoInTraceReturnChain = false;
         // by default halt the program when utils.haltOrThrow is calleds
         this.errorHandling = ErrorHandling.Halt;
+        // by default use clustering based on heurastics
+        this.isMLClustering = false;
+        // linkage max distance for caclulating distances among clusters
         this.mlClusteringLinkageMaxDistance = 0.7;
+        // TF/IDF maximum document frequency
+        this.mlMaxDF = 1;
     }
     // initialize configurable parameters
     init(options = {}) {

package/dist/lib/FileManager.js

@@ -41,8 +41,10 @@ class FileManager {
         return path_1.default.join(this.getTmpDir(), 'memlab');
     }
     generateTmpHeapDir() {
-        const dirPath = path_1.default.join(this.getTmpDir(), Utils_1.default.getUniqueID());
-        fs_extra_1.default.mkdirSync(dirPath);
+        const dirPath = path_1.default.join(this.getTmpDir(), 'memlab-' + Utils_1.default.getUniqueID());
+        if (!fs_extra_1.default.existsSync(dirPath)) {
+            fs_extra_1.default.mkdirSync(dirPath);
+        }
         return dirPath;
     }
     getWorkDir(options = {}) {

package/dist/lib/HeapAnalyzer.js

@@ -250,9 +250,17 @@ class MemoryAnalyst {
             let snapshotLeakedHeapNodeIdSet = new Set();
             let nodeIdsInSnapshots = [];
             let snapshot;
+            // if specified a heap file
             if (options.file) {
                 const opt = { buildNodeIdIndex: true, verbose: true };
                 snapshot = yield Utils_1.default.getSnapshotFromFile(options.file, opt);
+                // if running in interactive heap analysis mode
+            }
+            else if (Config_1.default.heapConfig &&
+                Config_1.default.heapConfig.isCliInteractiveMode &&
+                Config_1.default.heapConfig.currentHeap) {
+                snapshot = Config_1.default.heapConfig.currentHeap;
+                // otherwise diff heap snapshots
             }
             else {
                 Utils_1.default.checkSnapshots();
@@ -368,14 +376,17 @@ class MemoryAnalyst {
     // initialize the path finder
     preparePathFinder(snapshot) {
         const finder = new TraceFinder_1.default();
-        // shortest path for all nodes
-        finder.annotateShortestPaths(snapshot);
-        // dominator and retained size
-        finder.calculateAllNodesRetainedSizes(snapshot);
-        // mark detached Fiber nodes
-        Utils_1.default.markAllDetachedFiberNode(snapshot);
-        // mark alternate Fiber nodes
-        Utils_1.default.markAlternateFiberNode(snapshot);
+        if (!snapshot.isProcessed) {
+            // shortest path for all nodes
+            finder.annotateShortestPaths(snapshot);
+            // dominator and retained size
+            finder.calculateAllNodesRetainedSizes(snapshot);
+            // mark detached Fiber nodes
+            Utils_1.default.markAllDetachedFiberNode(snapshot);
+            // mark alternate Fiber nodes
+            Utils_1.default.markAlternateFiberNode(snapshot);
+            snapshot.isProcessed = true;
+        }
         return finder;
     }
     // summarize the page interaction and dump to the leak text summary file

package/dist/lib/NodeHeap.d.ts

@@ -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

@@ -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/Types.d.ts

@@ -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;
@@ -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) => {
@@ -1538,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) => {
@@ -1579,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;
@@ -1718,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;

package/dist/lib/heap-data/HeapSnapshot.js

@@ -18,11 +18,13 @@ const Console_1 = __importDefault(require("../Console"));
 const HeapNode_1 = __importDefault(require("./HeapNode"));
 const HeapEdge_1 = __importDefault(require("./HeapEdge"));
 const HeapUtils_1 = require("./HeapUtils");
+const MemLabTagStore_1 = __importDefault(require("./MemLabTagStore"));
 const EMPTY_UINT8_ARRAY = new Uint8Array(0);
 const EMPTY_UINT32_ARRAY = new Uint32Array(0);
 class HeapSnapshot {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     constructor(snapshot, _options = {}) {
+        this.isProcessed = false;
         this._nodeCount = -1;
         this._edgeCount = -1;
         this._nodeId2NodeIdx = {};
@@ -158,36 +160,7 @@ class HeapSnapshot {
         return detected;
     }
     hasObjectWithTag(tag) {
-        // get tagStore
-        let tagStore = null;
-        this.nodes.forEach((node) => {
-            if (node.name === 'MemLabTaggedStore' && node.type === 'object') {
-                tagStore = node;
-                return false;
-            }
-        });
-        if (tagStore == null) {
-            return false;
-        }
-        const store = tagStore;
-        // get tagStore.taggedObjects
-        const taggedObjects = store.getReferenceNode('taggedObjects', 'property');
-        if (taggedObjects == null) {
-            return false;
-        }
-        // get taggedObjects[tag]
-        const weakSet = taggedObjects.getReferenceNode(tag, 'property');
-        if (weakSet == null) {
-            return false;
-        }
-        // get weakSet.table
-        const table = weakSet.getReferenceNode('table');
-        if (table == null) {
-            return false;
-        }
-        // check if the table has any weak reference to any object
-        const ref = table.findAnyReference((edge) => edge.type === 'weak' && edge.toNode.name !== 'system / Oddball');
-        return ref != null;
+        return MemLabTagStore_1.default.hasObjectWithTag(this, tag);
     }
     getNodeById(id) {
         if (!(id in this._nodeId2NodeIdx)) {

package/dist/lib/heap-data/HeapStringNode.js

@@ -35,6 +35,8 @@ class HeapStringNode extends HeapNode_1.default {
             if (parentNode == null) {
                 throw (0, HeapUtils_1.throwError)(new Error('broken sliced string'));
             }
+            // sliced string in heap snapshot doesn't include
+            // the start index and the end index, so this may be inaccurate
             return parentNode.stringValue;
         }
         return this.name;

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

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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
+ */
+import type { AnyValue, IHeapSnapshot } from '../Types';
+declare type AnyObject = Record<AnyValue, AnyValue>;
+/** @internal */
+export default class MemLabTaggedStore {
+    taggedObjects: Record<string, WeakSet<AnyObject>>;
+    private constructor();
+    private static instance;
+    readonly id: string;
+    static getInstance(): MemLabTaggedStore;
+    static tagObject<T>(o: T, tag: string): void;
+    static hasObjectWithTag(heap: IHeapSnapshot, tag: string): boolean;
+}
+export {};
+//# sourceMappingURL=MemLabTagStore.d.ts.map

package/dist/lib/heap-data/MemLabTagStore.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = require("../..");
+let uindex = 1;
+function getUniqueID() {
+    const randId = `${Math.random()}`;
+    return `${process.pid}-${Date.now()}-${randId}-${uindex++}`;
+}
+/** @internal */
+class MemLabTaggedStore {
+    constructor() {
+        this.id = getUniqueID();
+        this.taggedObjects = Object.create(null);
+    }
+    // make sure it's a singleton
+    static getInstance() {
+        if (!MemLabTaggedStore.instance) {
+            MemLabTaggedStore.instance = new MemLabTaggedStore();
+        }
+        return MemLabTaggedStore.instance;
+    }
+    // tag an object with a mark
+    static tagObject(o, tag) {
+        const store = MemLabTaggedStore.getInstance();
+        if (!store.taggedObjects[tag]) {
+            store.taggedObjects[tag] = new WeakSet();
+        }
+        store.taggedObjects[tag].add(o);
+    }
+    // check if any object in the heap snapshot has the mark
+    // tagged by this MemLabTaggedStore in this execution context
+    static hasObjectWithTag(heap, tag) {
+        const curContextTagStoreID = MemLabTaggedStore.getInstance().id;
+        let tagStore = null;
+        // get all MemLabTaggedStore instances in the heap snapshot
+        const stores = [];
+        heap.nodes.forEach((node) => {
+            if (node.name === 'MemLabTaggedStore' && node.type === 'object') {
+                stores.push(node);
+            }
+        });
+        // if no tag store found
+        if (stores.length === 0) {
+            return false;
+            // if there is only one store found
+        }
+        else if (stores.length === 1) {
+            tagStore = stores[0];
+            // if there are multiple MemLabTagStore instances
+            // found in the heap snapshot
+        }
+        else if (stores.length > 1) {
+            stores.forEach((node) => {
+                // in case multiple instances of MemLabTaggedStore exists
+                // in the heap snapshot, we need to make sure that the
+                // tag store is the one matching the current execution context
+                let storeID = '';
+                // match tag store id
+                node.forEachReference(edge => {
+                    var _a, _b;
+                    if (edge.name_or_index === 'id' && edge.toNode.isString) {
+                        storeID = (_b = (_a = edge.toNode.toStringNode()) === null || _a === void 0 ? void 0 : _a.stringValue) !== null && _b !== void 0 ? _b : '';
+                        return { stop: true };
+                    }
+                });
+                if (curContextTagStoreID === storeID) {
+                    tagStore = node;
+                }
+            });
+            if (tagStore == null) {
+                throw __1.utils.haltOrThrow('Multiple MemLabTagStore instances found in heap snapshot ' +
+                    'when checking object tags, please make sure only one memlab ' +
+                    'instance is running at a time and double check that memlab is ' +
+                    'not running in Jest concurrent mode.');
+            }
+        }
+        if (tagStore == null) {
+            return false;
+        }
+        const store = tagStore;
+        // get tagStore.taggedObjects
+        const taggedObjects = store.getReferenceNode('taggedObjects', 'property');
+        if (taggedObjects == null) {
+            return false;
+        }
+        // get taggedObjects[tag]
+        const weakSet = taggedObjects.getReferenceNode(tag, 'property');
+        if (weakSet == null) {
+            return false;
+        }
+        // get weakSet.table
+        const table = weakSet.getReferenceNode('table');
+        if (table == null) {
+            return false;
+        }
+        // check if the table has any weak reference to any object
+        const ref = table.findAnyReference((edge) => edge.type === 'weak' && edge.toNode.name !== 'system / Oddball');
+        return ref != null;
+    }
+}
+exports.default = MemLabTaggedStore;

package/dist/trace-cluster/strategies/MLTraceSimilarityStrategy.js

@@ -32,7 +32,7 @@ class MLTraceSimilarityStrategy {
             if (!map.has(repTrace)) {
                 map.set(repTrace, [repTrace]);
             }
-            // to please lint
+            // to please linter
             (_a = map.get(repTrace)) === null || _a === void 0 ? void 0 : _a.push(trace);
         }
         return {

package/dist/trace-cluster/strategies/machine-learning/HAC.d.ts

@@ -13,5 +13,5 @@
  * @param {*} D condenced distance matrix
  * @returns labels - list of doc ids as clusters
  */
-export declare const cluster: (nDocs: number, condensedDistanceMatrix: Float32Array, maxDistanceThreshold: number) => number[];
+export declare const cluster: (nDocs: number, condensedDistanceMatrix: Float32Array, maxDistanceThreshold: number) => number[] | Uint32Array;
 //# sourceMappingURL=HAC.d.ts.map

package/dist/trace-cluster/strategies/machine-learning/HAC.js

@@ -18,13 +18,13 @@ const condensedIndex = (n, i, j) => {
     // (n - 1) + (n - 2) + ... + (n - i) + (j - i) - 1
     return n * i - (i * (i + 1)) / 2 + (j - i - 1);
 };
-const getRootLabel = (array, idx) => {
+function getRootLabel(array, idx) {
     let rootIdx = idx;
     while (array[rootIdx] !== rootIdx) {
         rootIdx = array[rootIdx];
     }
     return rootIdx;
-};
+}
 /**
  *
  * @param {*} nDocs number of docs
@@ -42,9 +42,7 @@ const cluster = (nDocs, condensedDistanceMatrix, maxDistanceThreshold) => {
     let traceBIdx = -1;
     let currentMin = Number.MAX_SAFE_INTEGER;
     let distanceBetweenTraces;
-    const labels = Array(nDocs)
-        .fill(0)
-        .map((_, idx) => idx);
+    const labels = new Uint32Array(nDocs).map((_, idx) => idx);
     for (let k = 0; k < nDocs - 1; k++) {
         traceBIdx = -1;
         if (chainLength === 0) {
@@ -77,7 +75,7 @@ const cluster = (nDocs, condensedDistanceMatrix, maxDistanceThreshold) => {
                     traceBIdx = i;
                 }
             }
-            // to make sure we found a two mutual traces whose distance is smallest.
+            // make sure that traceA and traceB are closest to each other
             if (chainLength > 1 &&
                 traceBIdx !== -1 &&
                 traceBIdx === clusterChain[chainLength - 2]) {

package/dist/trace-cluster/strategies/machine-learning/TfidfVectorizer.js

@@ -8,19 +8,23 @@
  * @emails oncall+ws_labs
  * @format
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TfidfVectorizer = void 0;
+const Config_1 = __importDefault(require("../../../lib/Config"));
 const Ngram_1 = require("./Ngram");
 const SMOOTHING_KEY = '__smoothObjectKey';
 const VOCAB_IDX_FOR_DOC_WITH_HIGH_DF = '-1';
 class TfidfVectorizer {
-    constructor({ rawDocuments, maxDF = 0.8 }) {
+    constructor({ rawDocuments, maxDF }) {
         this.rawDocuments = [];
         this.vocabulary = Object.create(null);
         this.documentFrequency = Object.create(null);
         this.documents = [];
         this.rawDocuments = rawDocuments;
-        this.maxDF = maxDF;
+        this.maxDF = maxDF !== null && maxDF !== void 0 ? maxDF : Config_1.default.mlMaxDF;
     }
     computeTfidfs() {
         const tokenizedDocuments = this.rawDocuments.map(this.tokenize);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memlab/core",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "license": "MIT",
   "description": "memlab core libraries",
   "author": "Liang Gong <lgong@fb.com>",