@memlab/api 1.0.2 → 1.0.5

package/README.md

@@ -3,5 +3,6 @@
 This is the memlab API library. Add this dependency to your project
 if you want to integrate memlab with your continuous testing system.
 
-## Full documentation
-https://facebookincubator.github.io/memlab
+## Online Resources
+* [Official Website and Demo](https://facebookincubator.github.io/memlab)
+* [Documentation](https://facebookincubator.github.io/memlab/docs/intro)

package/dist/API.d.ts

@@ -8,20 +8,26 @@
  * @format
  */
 import type { ParsedArgs } from 'minimist';
-import type { AnyFunction, AnyValue, ISerializedInfo, IScenario } from '@memlab/core';
+import type { AnyFunction, ISerializedInfo, IScenario } from '@memlab/core';
 import { MemLabConfig } from '@memlab/core';
 import { TestPlanner } from '@memlab/e2e';
 import { BaseAnalysis } from '@memlab/heap-analysis';
 import BrowserInteractionResultReader from './result-reader/BrowserInteractionResultReader';
 /**
- * Options for configuring browser interaction run
+ * Options for configuring browser interaction run, all fields are optional
  */
 export declare type RunOptions = {
-    /** test scenario definition */
+    /**
+     * test scenario specifying how to interact with browser
+     * (for more details view {@link IScenario})
+     */
     scenario?: IScenario;
-    /** cookies file */
+    /** the absolute path of cookies file */
     cookiesFile?: string;
-    /** function to be evaluated in browser context after the web page initial load */
+    /**
+     * function to be evaluated in browser context after
+     * the web page initial load
+     */
     evalInBrowserAfterInitLoad?: AnyFunction;
     /**
      * if true, take heap snapshot for each interaction step,
@@ -29,10 +35,33 @@ export declare type RunOptions = {
      * which steps it will take heap snapshots
      */
     snapshotForEachStep?: boolean;
+    /**
+     * specify the working directory where you want memlab to dump
+     * heap snapshots and other meta data of the test run. If no
+     * working directory is provided, memlab will generate a random
+     * temp directory under the operating system's default directory
+     * for temporary files.
+     * Note: It's the caller's responsibility to make sure the
+     * specified working directory exists.
+     */
+    workDir?: string;
+};
+/**
+ * A data structure holding the result of the {@link run} API call.
+ */
+export declare type RunResult = {
+    /**
+     * leak traces detected and clustered from the browser interaction
+     */
+    leaks: ISerializedInfo[];
+    /**
+     * a utility for reading browser interaction results from disk
+     */
+    runResult: BrowserInteractionResultReader;
 };
 /**
- * @ignore
  * Options for memlab inter-package API calls
+ * @internal
  */
 export declare type APIOptions = {
     testPlanner?: TestPlanner;
@@ -43,29 +72,62 @@ export declare type APIOptions = {
 /**
  * This API warms up web server, runs E2E interaction, and takes heap snapshots.
  * This is equivalent to run `memlab warmup-and-snapshot` in CLI.
- * This is also equivalent to call {@link warmup} and {@link takeSnapshots}.
+ * This is also equivalent to warm up and call {@link takeSnapshots}.
  *
  * @param options configure browser interaction run
  * @returns browser interaction results
+ * * **Examples**:
+ * ```javascript
+ * const {warmupAndTakeSnapshots} = require('@memlab/api');
+ *
+ * (async function () {
+ *   const scenario = {
+ *     url: () => 'https://www.facebook.com',
+ *   };
+ *   const result = await warmupAndTakeSnapshots({scenario});
+ * })();
+ * ```
  */
 export declare function warmupAndTakeSnapshots(options?: RunOptions): Promise<BrowserInteractionResultReader>;
 /**
  * This API runs browser interaction and find memory leaks triggered in browser
  * This is equivalent to run `memlab run` in CLI.
- * This is also equivalent to call {@link warmup}, {@link takeSnapshots},
+ * This is also equivalent to warm up, and call {@link takeSnapshots}
  * and {@link findLeaks}.
  *
- * @param options configure browser interaction run
- * @returns an array of leak traces detected and clustered from the
- * browser interaction
+ * @param runOptions configure browser interaction run
+ * @returns memory leaks detected and a utility reading browser
+ * interaction results from disk
+ * * **Examples**:
+ * ```javascript
+ * const {run} = require('@memlab/api');
+ *
+ * (async function () {
+ *   const scenario = {
+ *     url: () => 'https://www.facebook.com',
+ *   };
+ *   const {leaks} = await run({scenario});
+ * })();
+ * ```
  */
-export declare function run(options?: RunOptions): Promise<ISerializedInfo[]>;
+export declare function run(runOptions?: RunOptions): Promise<RunResult>;
 /**
  * This API runs E2E interaction and takes heap snapshots.
  * This is equivalent to run `memlab snapshot` in CLI.
  *
  * @param options configure browser interaction run
- * @returns browser interaction results
+ * @returns a utility reading browser interaction results from disk
+ * * **Examples**:
+ * ```javascript
+ * const {takeSnapshots} = require('@memlab/api');
+ *
+ * (async function () {
+ *   const scenario = {
+ *     url: () => 'https://www.facebook.com',
+ *   };
+ *   const result = await takeSnapshots({scenario});
+ * })();
+ * ```
  */
 export declare function takeSnapshots(options?: RunOptions): Promise<BrowserInteractionResultReader>;
 /**
@@ -73,8 +135,19 @@ export declare function takeSnapshots(options?: RunOptions): Promise<BrowserInte
  * This is equivalent to `memlab find-leaks` in CLI.
  *
  * @param runResult return value of a browser interaction run
- * @returns an array of leak traces detected and clustered from the
- * browser interaction
+ * @returns leak traces detected and clustered from the browser interaction
+ * * **Examples**:
+ * ```javascript
+ * const {findLeaks, takeSnapshots} = require('@memlab/api');
+ *
+ * (async function () {
+ *   const scenario = {
+ *     url: () => 'https://www.facebook.com',
+ *   };
+ *   const result = await takeSnapshots({scenario});
+ *   const leaks = findLeaks(result);
+ * })();
+ * ```
  */
 export declare function findLeaks(runResult: BrowserInteractionResultReader): Promise<ISerializedInfo[]>;
 /**
@@ -84,19 +157,35 @@ export declare function findLeaks(runResult: BrowserInteractionResultReader): Pr
  * @param runResult return value of a browser interaction run
  * @param heapAnalyzer instance of a heap analysis
  * @param args other CLI arguments that needs to be passed to the heap analysis
- * @returns
+ * @returns each analysis may have a different return type, please check out
+ * the type definition or the documentation for the `process` method of the
+ * analysis class you are using for `heapAnalyzer`.
+ * * **Examples**:
+ * ```javascript
+ * const {takeSnapshots, StringAnalysis} = require('@memlab/api');
+ *
+ * (async function () {
+ *   const scenario = {
+ *     url: () => 'https://www.facebook.com',
+ *   };
+ *   const result = await takeSnapshots({scenario});
+ *   const analysis = new StringAnalysis();
+ *   await analyze(result, analysis);
+ * })();
+ * ```
  */
-export declare function analyze(runResult: BrowserInteractionResultReader, heapAnalyzer: BaseAnalysis, args?: ParsedArgs): Promise<AnyValue>;
+export declare function analyze(runResult: BrowserInteractionResultReader, heapAnalyzer: BaseAnalysis, args?: ParsedArgs): Promise<void>;
 /**
- * @ignore
  * This warms up web server by sending web requests to the web sever.
  * This is equivalent to run `memlab warmup` in CLI.
+ * @internal
  *
  * @param options configure browser interaction run
  */
 export declare function warmup(options?: APIOptions): Promise<void>;
 /**
- * @ignore
+ * Browser interaction API used by MemLab API and MemLab CLI
+ * @internal
  */
 export declare function testInBrowser(options?: APIOptions): Promise<void>;
 //# sourceMappingURL=API.d.ts.map

package/dist/API.js

@@ -29,15 +29,25 @@ const BrowserInteractionResultReader_1 = __importDefault(require("./result-reade
 /**
  * This API warms up web server, runs E2E interaction, and takes heap snapshots.
  * This is equivalent to run `memlab warmup-and-snapshot` in CLI.
- * This is also equivalent to call {@link warmup} and {@link takeSnapshots}.
+ * This is also equivalent to warm up and call {@link takeSnapshots}.
  *
  * @param options configure browser interaction run
  * @returns browser interaction results
+ * * **Examples**:
+ * ```javascript
+ * const {warmupAndTakeSnapshots} = require('@memlab/api');
+ *
+ * (async function () {
+ *   const scenario = {
+ *     url: () => 'https://www.facebook.com',
+ *   };
+ *   const result = await warmupAndTakeSnapshots({scenario});
+ * })();
+ * ```
  */
 function warmupAndTakeSnapshots(options = {}) {
     return __awaiter(this, void 0, void 0, function* () {
-        const config = core_1.MemLabConfig.resetConfigWithTranscientDir();
-        setConfigByRunOptions(config, options);
+        const config = getConfigFromRunOptions(options);
         config.externalCookiesFile = options.cookiesFile;
         config.scenario = options.scenario;
         const testPlanner = new e2e_1.TestPlanner({ config });
@@ -51,25 +61,36 @@ exports.warmupAndTakeSnapshots = warmupAndTakeSnapshots;
 /**
  * This API runs browser interaction and find memory leaks triggered in browser
  * This is equivalent to run `memlab run` in CLI.
- * This is also equivalent to call {@link warmup}, {@link takeSnapshots},
+ * This is also equivalent to warm up, and call {@link takeSnapshots}
  * and {@link findLeaks}.
  *
- * @param options configure browser interaction run
- * @returns an array of leak traces detected and clustered from the
- * browser interaction
+ * @param runOptions configure browser interaction run
+ * @returns memory leaks detected and a utility reading browser
+ * interaction results from disk
+ * * **Examples**:
+ * ```javascript
+ * const {run} = require('@memlab/api');
+ *
+ * (async function () {
+ *   const scenario = {
+ *     url: () => 'https://www.facebook.com',
+ *   };
+ *   const {leaks} = await run({scenario});
+ * })();
+ * ```
  */
-function run(options = {}) {
+function run(runOptions = {}) {
     return __awaiter(this, void 0, void 0, function* () {
-        const config = core_1.MemLabConfig.resetConfigWithTranscientDir();
-        setConfigByRunOptions(config, options);
-        config.externalCookiesFile = options.cookiesFile;
-        config.scenario = options.scenario;
+        const config = getConfigFromRunOptions(runOptions);
+        config.externalCookiesFile = runOptions.cookiesFile;
+        config.scenario = runOptions.scenario;
         const testPlanner = new e2e_1.TestPlanner({ config });
-        const { evalInBrowserAfterInitLoad } = options;
+        const { evalInBrowserAfterInitLoad } = runOptions;
         yield warmup({ testPlanner, config, evalInBrowserAfterInitLoad });
         yield testInBrowser({ testPlanner, config, evalInBrowserAfterInitLoad });
         const runResult = BrowserInteractionResultReader_1.default.from(config.workDir);
-        return yield findLeaks(runResult);
+        const leaks = yield findLeaks(runResult);
+        return { leaks, runResult };
     });
 }
 exports.run = run;
@@ -78,12 +99,22 @@ exports.run = run;
  * This is equivalent to run `memlab snapshot` in CLI.
  *
  * @param options configure browser interaction run
- * @returns browser interaction results
+ * @returns a utility reading browser interaction results from disk
+ * * **Examples**:
+ * ```javascript
+ * const {takeSnapshots} = require('@memlab/api');
+ *
+ * (async function () {
+ *   const scenario = {
+ *     url: () => 'https://www.facebook.com',
+ *   };
+ *   const result = await takeSnapshots({scenario});
+ * })();
+ * ```
  */
 function takeSnapshots(options = {}) {
     return __awaiter(this, void 0, void 0, function* () {
-        const config = core_1.MemLabConfig.resetConfigWithTranscientDir();
-        setConfigByRunOptions(config, options);
+        const config = getConfigFromRunOptions(options);
         config.externalCookiesFile = options.cookiesFile;
         config.scenario = options.scenario;
         const testPlanner = new e2e_1.TestPlanner();
@@ -98,8 +129,19 @@ exports.takeSnapshots = takeSnapshots;
  * This is equivalent to `memlab find-leaks` in CLI.
  *
  * @param runResult return value of a browser interaction run
- * @returns an array of leak traces detected and clustered from the
- * browser interaction
+ * @returns leak traces detected and clustered from the browser interaction
+ * * **Examples**:
+ * ```javascript
+ * const {findLeaks, takeSnapshots} = require('@memlab/api');
+ *
+ * (async function () {
+ *   const scenario = {
+ *     url: () => 'https://www.facebook.com',
+ *   };
+ *   const result = await takeSnapshots({scenario});
+ *   const leaks = findLeaks(result);
+ * })();
+ * ```
  */
 function findLeaks(runResult) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -117,7 +159,22 @@ exports.findLeaks = findLeaks;
  * @param runResult return value of a browser interaction run
  * @param heapAnalyzer instance of a heap analysis
  * @param args other CLI arguments that needs to be passed to the heap analysis
- * @returns
+ * @returns each analysis may have a different return type, please check out
+ * the type definition or the documentation for the `process` method of the
+ * analysis class you are using for `heapAnalyzer`.
+ * * **Examples**:
+ * ```javascript
+ * const {takeSnapshots, StringAnalysis} = require('@memlab/api');
+ *
+ * (async function () {
+ *   const scenario = {
+ *     url: () => 'https://www.facebook.com',
+ *   };
+ *   const result = await takeSnapshots({scenario});
+ *   const analysis = new StringAnalysis();
+ *   await analyze(result, analysis);
+ * })();
+ * ```
  */
 function analyze(runResult, heapAnalyzer, args = { _: [] }) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -128,9 +185,9 @@ function analyze(runResult, heapAnalyzer, args = { _: [] }) {
 }
 exports.analyze = analyze;
 /**
- * @ignore
  * This warms up web server by sending web requests to the web sever.
  * This is equivalent to run `memlab warmup` in CLI.
+ * @internal
  *
  * @param options configure browser interaction run
  */
@@ -174,8 +231,16 @@ function warmup(options = {}) {
     });
 }
 exports.warmup = warmup;
-function setConfigByRunOptions(config, options) {
+function getConfigFromRunOptions(options) {
+    let config = core_1.MemLabConfig.getInstance();
+    if (options.workDir) {
+        core_1.fileManager.initDirs(config, { workDir: options.workDir });
+    }
+    else {
+        config = core_1.MemLabConfig.resetConfigWithTranscientDir();
+    }
     config.isFullRun = !!options.snapshotForEachStep;
+    return config;
 }
 function setupPage(page, options = {}) {
     var _a, _b, _c;
@@ -221,7 +286,8 @@ function initBrowserInfoInConfig(browser, options = {}) {
     });
 }
 /**
- * @ignore
+ * Browser interaction API used by MemLab API and MemLab CLI
+ * @internal
  */
 function testInBrowser(options = {}) {
     var _a, _b;

package/dist/__tests__/API/E2EFindLeaks.example.js

@@ -43,7 +43,7 @@ function inject() {
 }
 function test() {
     return __awaiter(this, void 0, void 0, function* () {
-        const leaks = yield (0, index_1.run)({ scenario, evalInBrowserAfterInitLoad: inject });
+        const { leaks } = yield (0, index_1.run)({ scenario, evalInBrowserAfterInitLoad: inject });
         core_1.info.lowLevel(`${leaks.length}`);
     });
 }

package/dist/__tests__/API/E2EFindMemoryLeaks.test.js

@@ -17,14 +17,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/ban-ts-comment */
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
 const index_1 = require("../../index");
 const E2ETestSettings_1 = require("./lib/E2ETestSettings");
 beforeEach(E2ETestSettings_1.testSetup);
 function injectDetachedDOMElements() {
     // @ts-ignore
     window.injectHookForLink4 = () => {
+        class TestObject {
+        }
         const arr = [];
         for (let i = 0; i < 23; ++i) {
             arr.push(document.createElement('div'));
@@ -35,17 +42,42 @@ function injectDetachedDOMElements() {
         window._path_1 = { x: { y: document.createElement('div') } };
         // @ts-ignore
         window._path_2 = new Set([document.createElement('div')]);
+        // @ts-ignore
+        window._randomObject = [new TestObject()];
     };
 }
 test('leak detector can find detached DOM elements', () => __awaiter(void 0, void 0, void 0, function* () {
-    const leaks = yield (0, index_1.run)({
+    const { leaks } = yield (0, index_1.run)({
         scenario: E2ETestSettings_1.scenario,
         evalInBrowserAfterInitLoad: injectDetachedDOMElements,
     });
     // detected all different leak trace cluster
-    expect(leaks.length).toBe(3);
+    expect(leaks.length >= 1).toBe(true);
     // expect all traces are found
     expect(leaks.some(leak => JSON.stringify(leak).includes('__injectedValue')));
     expect(leaks.some(leak => JSON.stringify(leak).includes('_path_1')));
     expect(leaks.some(leak => JSON.stringify(leak).includes('_path_2')));
 }), E2ETestSettings_1.testTimeout);
+test('self-defined leak detector can find TestObject', () => __awaiter(void 0, void 0, void 0, function* () {
+    const selfDefinedScenario = {
+        app: () => 'test-spa',
+        url: () => '',
+        action: (page) => __awaiter(void 0, void 0, void 0, function* () { return yield page.click('[data-testid="link-4"]'); }),
+        leakFilter: (node) => {
+            return node.name === 'TestObject' && node.type === 'object';
+        },
+    };
+    const workDir = path_1.default.join(os_1.default.tmpdir(), 'memlab-api-test', `${process.pid}`);
+    fs_extra_1.default.mkdirsSync(workDir);
+    const result = yield (0, index_1.run)({
+        scenario: selfDefinedScenario,
+        evalInBrowserAfterInitLoad: injectDetachedDOMElements,
+        workDir,
+    });
+    // detected all different leak trace cluster
+    expect(result.leaks.length).toBe(1);
+    // expect all traces are found
+    expect(result.leaks.some(leak => JSON.stringify(leak).includes('_randomObject')));
+    const reader = result.runResult;
+    expect(path_1.default.resolve(reader.getRootDirectory())).toBe(path_1.default.resolve(workDir));
+}), E2ETestSettings_1.testTimeout);

package/dist/__tests__/API/E2EShapeUnboundGrowthAnalysis.test.js

@@ -47,12 +47,14 @@ test('Shape unbound analysis works as expected', () => __awaiter(void 0, void 0,
     });
     // test analysis from auto loading
     let analysis = new index_1.ShapeUnboundGrowthAnalysis();
-    let shapeSummary = yield analysis.run();
+    yield analysis.run();
+    let shapeSummary = analysis.getShapesWithUnboundGrowth();
     expect(shapeSummary.reduce((acc, summary) => acc || summary.shape.includes('LeakObject'), false)).toBe(true);
     // test analysis from file
     const snapshotDir = result.getSnapshotFileDir();
     analysis = new index_1.ShapeUnboundGrowthAnalysis();
-    shapeSummary = yield analysis.analyzeSnapshotsInDirectory(snapshotDir);
+    yield analysis.analyzeSnapshotsInDirectory(snapshotDir);
+    shapeSummary = analysis.getShapesWithUnboundGrowth();
     expect(shapeSummary.some((summary) => summary.shape.includes('LeakObject'))).toBe(true);
     // expect incorrect use of heap analysis to throw
     const snapshotFile = result.getSnapshotFiles().pop();

package/dist/__tests__/heap/examples/example-1.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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
+ */
+export {};
+//# sourceMappingURL=example-1.d.ts.map

package/dist/__tests__/heap/examples/example-1.js

@@ -0,0 +1,37 @@
+"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
+ */
+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");
+class TestObject {
+    constructor() {
+        this.arr1 = [1, 2, 3];
+        this.arr2 = ['1', '2', '3'];
+    }
+}
+(function () {
+    return __awaiter(this, void 0, void 0, function* () {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const obj = new TestObject();
+        // get a heap snapshot of the current program state
+        const heap = yield (0, core_1.getNodeInnocentHeap)();
+        const node = heap.getAnyObjectWithClassName('TestObject');
+        console.log(node === null || node === void 0 ? void 0 : node.name);
+    });
+})();

package/dist/__tests__/heap/examples/example-2.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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
+ */
+export {};
+//# sourceMappingURL=example-2.d.ts.map

package/dist/__tests__/heap/examples/example-2.js

@@ -0,0 +1,33 @@
+"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
+ */
+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 heap_analysis_1 = require("@memlab/heap-analysis");
+(function () {
+    return __awaiter(this, void 0, void 0, function* () {
+        const heapFile = (0, core_1.dumpNodeHeapSnapshot)();
+        const heap = yield (0, heap_analysis_1.getHeapFromFile)(heapFile);
+        // get the total number of heap objects
+        heap.nodes.length;
+        heap.nodes.forEach((node) => {
+            console.log(node.name);
+        });
+    });
+})();

package/dist/__tests__/heap/examples/example-3.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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
+ */
+export {};
+//# sourceMappingURL=example-3.d.ts.map

package/dist/__tests__/heap/examples/example-3.js

@@ -0,0 +1,33 @@
+"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
+ */
+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 heap_analysis_1 = require("@memlab/heap-analysis");
+(function () {
+    return __awaiter(this, void 0, void 0, function* () {
+        const heapFile = (0, core_1.dumpNodeHeapSnapshot)();
+        const heap = yield (0, heap_analysis_1.getHeapFromFile)(heapFile);
+        // get the total number of heap references
+        heap.edges.length;
+        heap.edges.forEach((edge) => {
+            console.log(edge.name_or_index);
+        });
+    });
+})();

package/dist/__tests__/heap/examples/example-4.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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
+ */
+export {};
+//# sourceMappingURL=example-4.d.ts.map