@memlab/api 1.0.0 → 1.0.3

package/README.md

@@ -1,11 +1,7 @@
-# `@memlab/api`
+## memlab API
 
-> TODO: description
+This is the memlab API library. Add this dependency to your project
+if you want to integrate memlab with your continuous testing system.
 
-## Usage
-
-```
-const api = require('@memlab/api');
-
-// TODO: DEMONSTRATE API
-```
+## Full documentation
+https://facebookincubator.github.io/memlab

package/dist/API.d.ts

@@ -7,34 +7,155 @@
  * @emails oncall+ws_labs
  * @format
  */
-import type { Page } from 'puppeteer';
 import type { ParsedArgs } from 'minimist';
-import type { AnyFunction, E2EStepInfo, IScenario, RunMetaInfo } 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';
-declare type APIOptions = {
-    testPlanner?: TestPlanner;
-    cache?: boolean;
-    config?: MemLabConfig;
-    evalInBrowserAfterInitLoad?: AnyFunction;
-};
-declare type RunOptions = {
+import BrowserInteractionResultReader from './result-reader/BrowserInteractionResultReader';
+/**
+ * Options for configuring browser interaction run, all fields are optional
+ */
+export declare type RunOptions = {
+    /** test scenario definition */
     scenario?: IScenario;
+    /** the absolute path of cookies file */
     cookiesFile?: string;
+    /** function to be evaluated in browser context after the web page initial load */
     evalInBrowserAfterInitLoad?: AnyFunction;
+    /**
+     * if true, take heap snapshot for each interaction step,
+     * by default this is false, which means memlab will decide
+     * which steps it will take heap snapshots
+     */
     snapshotForEachStep?: boolean;
 };
-declare type RunResult = {
-    config: MemLabConfig;
-    tabsOrder: E2EStepInfo[];
-    metaInfo: RunMetaInfo;
+/**
+ * Options for memlab inter-package API calls
+ * @internal
+ */
+export declare type APIOptions = {
+    testPlanner?: TestPlanner;
+    cache?: boolean;
+    config?: MemLabConfig;
+    evalInBrowserAfterInitLoad?: AnyFunction;
 };
-export declare function run(options?: RunOptions): Promise<RunResult>;
-export declare function takeSnapshots(options?: RunOptions): Promise<RunResult>;
-export declare function analyze(runResult: RunResult, heapAnalyzer: BaseAnalysis, args?: ParsedArgs): Promise<void>;
+/**
+ * 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 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 warm up, and call {@link takeSnapshots}
+ * and {@link findLeaks}.
+ *
+ * @param runOptions configure browser interaction run
+ * @returns leak traces detected and clustered from the browser interaction
+ * * **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(runOptions?: RunOptions): Promise<ISerializedInfo[]>;
+/**
+ * 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
+ * * **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>;
+/**
+ * This API finds memory leaks by analyzing heap snapshot(s)
+ * This is equivalent to `memlab find-leaks` in CLI.
+ *
+ * @param runResult return value of a browser interaction run
+ * @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[]>;
+/**
+ * This API analyzes heap snapshot(s) with a specified heap analysis.
+ * This is equivalent to `memlab analyze` in CLI.
+ *
+ * @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 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<void>;
+/**
+ * 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>;
-export declare function setupPage(page: Page, options?: APIOptions): Promise<void>;
+/**
+ * Browser interaction API used by MemLab API and MemLab CLI
+ * @internal
+ */
 export declare function testInBrowser(options?: APIOptions): Promise<void>;
-export {};
 //# sourceMappingURL=API.d.ts.map

package/dist/API.js

@@ -21,14 +21,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testInBrowser = exports.setupPage = exports.warmup = exports.analyze = exports.takeSnapshots = exports.run = void 0;
+exports.testInBrowser = exports.warmup = exports.analyze = exports.findLeaks = exports.takeSnapshots = exports.run = exports.warmupAndTakeSnapshots = void 0;
 const core_1 = require("@memlab/core");
 const e2e_1 = require("@memlab/e2e");
 const APIUtils_1 = __importDefault(require("./lib/APIUtils"));
-function setConfigByRunOptions(config, options) {
-    config.isFullRun = !!options.snapshotForEachStep;
-}
-function run(options = {}) {
+const BrowserInteractionResultReader_1 = __importDefault(require("./result-reader/BrowserInteractionResultReader"));
+/**
+ * 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 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);
@@ -38,14 +55,63 @@ function run(options = {}) {
         const { evalInBrowserAfterInitLoad } = options;
         yield warmup({ testPlanner, config, evalInBrowserAfterInitLoad });
         yield testInBrowser({ testPlanner, config, evalInBrowserAfterInitLoad });
-        return {
-            config,
-            tabsOrder: core_1.utils.loadTabsOrder(),
-            metaInfo: core_1.utils.loadRunMetaInfo(),
-        };
+        return BrowserInteractionResultReader_1.default.from(config.workDir);
+    });
+}
+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 warm up, and call {@link takeSnapshots}
+ * and {@link findLeaks}.
+ *
+ * @param runOptions configure browser interaction run
+ * @returns leak traces detected and clustered from the browser interaction
+ * * **Examples**:
+ * ```javascript
+ * const {run} = require('@memlab/api');
+ *
+ * (async function () {
+ *   const scenario = {
+ *     url: () => 'https://www.facebook.com',
+ *   };
+ *   const leaks = await run({scenario});
+ * })();
+ * ```
+ */
+function run(runOptions = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const config = core_1.MemLabConfig.resetConfigWithTranscientDir();
+        setConfigByRunOptions(config, runOptions);
+        config.externalCookiesFile = runOptions.cookiesFile;
+        config.scenario = runOptions.scenario;
+        const testPlanner = new e2e_1.TestPlanner({ config });
+        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);
     });
 }
 exports.run = run;
+/**
+ * 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
+ * * **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();
@@ -55,20 +121,77 @@ function takeSnapshots(options = {}) {
         const testPlanner = new e2e_1.TestPlanner();
         const { evalInBrowserAfterInitLoad } = options;
         yield testInBrowser({ testPlanner, config, evalInBrowserAfterInitLoad });
-        return {
-            config,
-            tabsOrder: core_1.utils.loadTabsOrder(),
-            metaInfo: core_1.utils.loadRunMetaInfo(),
-        };
+        return BrowserInteractionResultReader_1.default.from(config.workDir);
     });
 }
 exports.takeSnapshots = takeSnapshots;
+/**
+ * This API finds memory leaks by analyzing heap snapshot(s)
+ * This is equivalent to `memlab find-leaks` in CLI.
+ *
+ * @param runResult return value of a browser interaction run
+ * @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* () {
+        const workDir = runResult.getRootDirectory();
+        core_1.fileManager.initDirs(core_1.config, { workDir });
+        core_1.config.chaseWeakMapEdge = false;
+        return yield core_1.analysis.checkLeak();
+    });
+}
+exports.findLeaks = findLeaks;
+/**
+ * This API analyzes heap snapshot(s) with a specified heap analysis.
+ * This is equivalent to `memlab analyze` in CLI.
+ *
+ * @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 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* () {
-        yield heapAnalyzer.run({ args });
+        const workDir = runResult.getRootDirectory();
+        core_1.fileManager.initDirs(core_1.config, { workDir });
+        return yield heapAnalyzer.run({ args });
     });
 }
 exports.analyze = analyze;
+/**
+ * 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
+ */
 function warmup(options = {}) {
     var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
@@ -109,6 +232,9 @@ function warmup(options = {}) {
     });
 }
 exports.warmup = warmup;
+function setConfigByRunOptions(config, options) {
+    config.isFullRun = !!options.snapshotForEachStep;
+}
 function setupPage(page, options = {}) {
     var _a, _b, _c;
     return __awaiter(this, void 0, void 0, function* () {
@@ -130,7 +256,6 @@ function setupPage(page, options = {}) {
         }));
     });
 }
-exports.setupPage = setupPage;
 function autoDismissDialog(page, options = {}) {
     var _a;
     const config = (_a = options.config) !== null && _a !== void 0 ? _a : core_1.config;
@@ -153,6 +278,10 @@ function initBrowserInfoInConfig(browser, options = {}) {
         }
     });
 }
+/**
+ * Browser interaction API used by MemLab API and MemLab CLI
+ * @internal
+ */
 function testInBrowser(options = {}) {
     var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {

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

@@ -17,12 +17,8 @@ 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 path_1 = __importDefault(require("path"));
 const index_1 = require("../../index");
 const E2ETestSettings_1 = require("./lib/E2ETestSettings");
 beforeEach(E2ETestSettings_1.testSetup);
@@ -34,14 +30,17 @@ function inject() {
     };
 }
 test('Detached DOM analysis works as expected', () => __awaiter(void 0, void 0, void 0, function* () {
-    const result = yield (0, index_1.run)({ scenario: E2ETestSettings_1.scenario, evalInBrowserAfterInitLoad: inject });
+    const result = yield (0, index_1.warmupAndTakeSnapshots)({
+        scenario: E2ETestSettings_1.scenario,
+        evalInBrowserAfterInitLoad: inject,
+    });
     // test analysis from auto loading
     let analysis = new index_1.DetachedDOMElementAnalysis();
     yield analysis.run();
     let domElems = analysis.getDetachedElements();
     expect(domElems.some(node => node.name === 'Detached HTMLTableElement')).toBe(true);
     // test analysis from file
-    const snapshotFile = path_1.default.join(result.config.curDataDir, 's3.heapsnapshot');
+    const snapshotFile = result.getSnapshotFiles().pop();
     analysis = new index_1.DetachedDOMElementAnalysis();
     yield analysis.analyzeSnapshotFromFile(snapshotFile);
     domElems = analysis.getDetachedElements();

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

@@ -17,11 +17,7 @@ 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 });
-const path_1 = __importDefault(require("path"));
 const index_1 = require("../../index");
 const E2ETestSettings_1 = require("./lib/E2ETestSettings");
 beforeEach(E2ETestSettings_1.testSetup);
@@ -39,14 +35,17 @@ function inject() {
     };
 }
 test('Duplicate object analysis works as expected', () => __awaiter(void 0, void 0, void 0, function* () {
-    const result = yield (0, index_1.run)({ scenario: E2ETestSettings_1.scenario, evalInBrowserAfterInitLoad: inject });
+    const result = yield (0, index_1.warmupAndTakeSnapshots)({
+        scenario: E2ETestSettings_1.scenario,
+        evalInBrowserAfterInitLoad: inject,
+    });
     // test analysis from auto loading
     let analysis = new index_1.ObjectShallowAnalysis();
     yield analysis.run();
     let dupcatedObjectInfo = analysis.getTopDuplicatedObjectInCount();
     expect(dupcatedObjectInfo[0].n).toBe(12345);
     // test analysis from file
-    const snapshotFile = path_1.default.join(result.config.curDataDir, 's3.heapsnapshot');
+    const snapshotFile = result.getSnapshotFiles().pop();
     analysis = new index_1.ObjectShallowAnalysis();
     yield analysis.analyzeSnapshotFromFile(snapshotFile);
     dupcatedObjectInfo = analysis.getTopDuplicatedObjectInCount();

package/dist/__tests__/API/E2EFindLeaks.example.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=E2EFindLeaks.example.d.ts.map

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

@@ -0,0 +1,50 @@
+"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 });
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const core_1 = require("@memlab/core");
+const index_1 = require("../../index");
+const scenario = {
+    app: () => 'test-spa',
+    url: () => '',
+    action: (page) => __awaiter(void 0, void 0, void 0, function* () { return yield page.click('[data-testid="link-4"]'); }),
+};
+function inject() {
+    // @ts-ignore
+    window.injectHookForLink4 = () => {
+        const arr = [];
+        for (let i = 0; i < 23; ++i) {
+            arr.push(document.createElement('div'));
+        }
+        // @ts-ignore
+        window.__injectedValue = arr;
+        // @ts-ignore
+        window._path_1 = { x: { y: document.createElement('div') } };
+        // @ts-ignore
+        window._path_2 = new Set([document.createElement('div')]);
+    };
+}
+function test() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const leaks = yield (0, index_1.run)({ scenario, evalInBrowserAfterInitLoad: inject });
+        core_1.info.lowLevel(`${leaks.length}`);
+    });
+}
+test();

package/dist/__tests__/API/E2EFindMemoryLeaks.test.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=E2EFindMemoryLeaks.test.d.ts.map

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

@@ -0,0 +1,72 @@
+"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 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'));
+        }
+        // @ts-ignore
+        window.__injectedValue = arr;
+        // @ts-ignore
+        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)({
+        scenario: E2ETestSettings_1.scenario,
+        evalInBrowserAfterInitLoad: injectDetachedDOMElements,
+    });
+    // detected all different leak trace cluster
+    expect(leaks.length).toBe(3);
+    // 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 leaks = yield (0, index_1.run)({
+        scenario: selfDefinedScenario,
+        evalInBrowserAfterInitLoad: injectDetachedDOMElements,
+    });
+    // detected all different leak trace cluster
+    expect(leaks.length).toBe(1);
+    // expect all traces are found
+    expect(leaks.some(leak => JSON.stringify(leak).includes('_randomObject')));
+}), E2ETestSettings_1.testTimeout);

package/dist/__tests__/API/E2EResultReader.test.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=E2EResultReader.test.d.ts.map