@memlab/core 1.1.19 → 1.1.21

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

@@ -28,7 +28,7 @@ beforeEach(() => {
 });
 const timeout = 5 * 60 * 1000;
 test('String heap object APIs work', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e, _f;
     class TestObject {
         constructor() {
             this.originalString = 'test';
@@ -44,6 +44,8 @@ test('String heap object APIs work', () => __awaiter(void 0, void 0, void 0, fun
     const heap = yield (0, NodeHeap_1.takeNodeMinimalHeap)();
     const testObject = heap.getAnyObjectWithClassName('TestObject');
     expect(testObject).not.toBe(null);
+    // test the number of referrers getter
+    expect(testObject === null || testObject === void 0 ? void 0 : testObject.numOfReferrers).toBeGreaterThan(0);
     // testObject.originalString === 'test'
     const originalString = testObject === null || testObject === void 0 ? void 0 : testObject.getReferenceNode('originalString');
     expect(originalString === null || originalString === void 0 ? void 0 : originalString.isString).toBe(true);
@@ -58,4 +60,13 @@ test('String heap object APIs work', () => __awaiter(void 0, void 0, void 0, fun
     expect(complexConcatString === null || complexConcatString === void 0 ? void 0 : complexConcatString.type).toBe('concatenated string');
     expect(complexConcatString === null || complexConcatString === void 0 ? void 0 : complexConcatString.isString).toBe(true);
     expect((_c = complexConcatString === null || complexConcatString === void 0 ? void 0 : complexConcatString.toStringNode()) === null || _c === void 0 ? void 0 : _c.stringValue).toBe('prefix_value_123_suffix');
+    // test the toJSONString API
+    let strRepresentation = (_d = concatString === null || concatString === void 0 ? void 0 : concatString.toJSONString()) !== null && _d !== void 0 ? _d : '{}';
+    let rep = JSON.parse(strRepresentation);
+    expect(rep.type).toBe('concatenated string');
+    expect(rep.stringValue).toBe(undefined);
+    strRepresentation = (_f = (_e = concatString === null || concatString === void 0 ? void 0 : concatString.toStringNode()) === null || _e === void 0 ? void 0 : _e.toJSONString()) !== null && _f !== void 0 ? _f : '{}';
+    rep = JSON.parse(strRepresentation);
+    expect(rep.type).toBe('concatenated string');
+    expect(rep.stringValue).toBe('prefix_suffix');
 }), timeout);

package/dist/index.d.ts

@@ -26,6 +26,8 @@ export { default as utils } from './lib/Utils';
 /** @internal */
 export { default as fileManager } from './lib/FileManager';
 /** @internal */
+export { default as runInfoUtils } from './lib/RunInfoUtils';
+/** @internal */
 export * from './lib/FileManager';
 /** @internal */
 export { default as serializer } from './lib/Serializer';

package/dist/index.js

@@ -35,7 +35,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TraceFinder = exports.MultiIterationSeqClustering = exports.SequentialClustering = exports.EvaluationMetric = exports.NormalizedTrace = exports.leakClusterLogger = exports.ProcessManager = exports.modes = exports.memoryBarChart = exports.constant = exports.analysis = exports.browserInfo = exports.serializer = exports.fileManager = exports.utils = exports.BaseOption = exports.info = exports.config = exports.registerPackage = void 0;
+exports.TraceFinder = exports.MultiIterationSeqClustering = exports.SequentialClustering = exports.EvaluationMetric = exports.NormalizedTrace = exports.leakClusterLogger = exports.ProcessManager = exports.modes = exports.memoryBarChart = exports.constant = exports.analysis = exports.browserInfo = exports.serializer = exports.runInfoUtils = exports.fileManager = exports.utils = exports.BaseOption = exports.info = exports.config = exports.registerPackage = void 0;
 const path_1 = __importDefault(require("path"));
 const PackageInfoLoader_1 = require("./lib/PackageInfoLoader");
 __exportStar(require("./lib/Types"), exports);
@@ -67,6 +67,9 @@ Object.defineProperty(exports, "utils", { enumerable: true, get: function () { r
 var FileManager_1 = require("./lib/FileManager");
 Object.defineProperty(exports, "fileManager", { enumerable: true, get: function () { return __importDefault(FileManager_1).default; } });
 /** @internal */
+var RunInfoUtils_1 = require("./lib/RunInfoUtils");
+Object.defineProperty(exports, "runInfoUtils", { enumerable: true, get: function () { return __importDefault(RunInfoUtils_1).default; } });
+/** @internal */
 __exportStar(require("./lib/FileManager"), exports);
 /** @internal */
 var Serializer_1 = require("./lib/Serializer");

package/dist/lib/Config.d.ts

@@ -99,6 +99,7 @@ export declare class MemLabConfig {
     dataBuilderDataDir: string;
     unclassifiedClusterDir: string;
     externalCookiesFile: Optional<string>;
+    extraRunInfoMap: Map<string, string>;
     heapConfig: Optional<IHeapConfig>;
     puppeteerConfig: LaunchOptions & BrowserLaunchArgumentOptions & BrowserConnectOptions;
     openDevtoolsConsole: boolean;
@@ -196,6 +197,8 @@ export declare class MemLabConfig {
     seqClusteringIsRandomChunks: boolean;
     instrumentJS: boolean;
     interceptScript: boolean;
+    isAnalyzingMainThread: boolean;
+    targetWorkerTitle: Nullable<string>;
     constructor(options?: ConfigOption);
     private initInternalConfigs;
     private init;
@@ -223,6 +226,7 @@ export declare class MemLabConfig {
     setDevice(deviceName: string, options?: {
         manualOverride?: boolean;
     }): void;
+    setRunInfo(key: string, value: string): void;
     private removeFromSet;
     private addToSet;
     enableXvfb(display: string): void;

package/dist/lib/Config.js

@@ -176,6 +176,12 @@ class MemLabConfig {
         // if true, split dataset into trunks
         // with random order for sequential clustering
         this.seqClusteringIsRandomChunks = false;
+        // extra E2E run info (other than the fields defined in
+        // RunMetaInfo like app, interaction, browserInfo).
+        // Information saved in this map will be
+        // auto-serialized to run-meta.json when the file is saved
+        // and auto-deserialized from run-meta.json when the file is loaded
+        this.extraRunInfoMap = new Map();
     }
     // initialize configurable parameters
     init(options = {}) {
@@ -211,6 +217,10 @@ class MemLabConfig {
         this.isManualDebug = false;
         // number of warmup repeat in each browser tab instance
         this.warmupRepeat = 2;
+        // by default, analyzing heap in main thread
+        this.isAnalyzingMainThread = true;
+        // target worker's title
+        this.targetWorkerTitle = null;
         // default waiting time when there is no page load checker callback
         this.delayWhenNoPageLoadCheck = 2000;
         // repeat the intermediate sequence
@@ -503,6 +513,9 @@ class MemLabConfig {
         this.puppeteerConfig.defaultViewport = null;
         this.defaultUserAgent = null;
     }
+    setRunInfo(key, value) {
+        this.extraRunInfoMap.set(key, value);
+    }
     removeFromSet(set, list) {
         for (const v of list) {
             set.delete(v);

package/dist/lib/FileManager.d.ts

@@ -10,6 +10,8 @@
 import type { MemLabConfig } from './Config';
 import type { AnyValue, FileOption } from './Types';
 /** @internal */
+export declare function joinAndProcessDir(options: FileOption, ...args: AnyValue[]): string;
+/** @internal */
 export declare class FileManager {
     private memlabConfigCache;
     getDefaultWorkDir(): string;
@@ -51,7 +53,9 @@ export declare class FileManager {
     getPreviewReportDir(options?: FileOption): string;
     getLeakSummaryFile(options?: FileOption): string;
     getRunMetaFile(options?: FileOption): string;
+    getRunMetaExternalTemplateFile(): string;
     getSnapshotSequenceMetaFile(options?: FileOption): string;
+    getSnapshotSequenceExternalTemplateFile(): string;
     getInputDataDir(): string;
     getAllFilesInSubDirs(dir: string): string[];
     getTmpDir(): string;
@@ -72,6 +76,8 @@ export declare class FileManager {
     iterateAllFiles(dir: string, callback: (filepath: string) => AnyValue): void;
     rmWorkDir(options?: FileOption): void;
     isWithinInternalDirectory(filePath: string): boolean;
+    createDefaultVisitOrderMetaFile(options?: FileOption): void;
+    createDefaultVisitOrderMetaFileWithSingleSnapshot(options: FileOption | undefined, snapshotFile: string): void;
     initDirs(config: MemLabConfig, options?: FileOption): void;
 }
 declare const _default: FileManager;

package/dist/lib/FileManager.js

@@ -12,13 +12,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileManager = void 0;
+exports.FileManager = exports.joinAndProcessDir = void 0;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const Console_1 = __importDefault(require("./Console"));
 const Constant_1 = __importDefault(require("./Constant"));
 const Utils_1 = __importDefault(require("./Utils"));
+/** @internal */
 function joinAndProcessDir(options, ...args) {
     const filepath = path_1.default.join(...args);
     if (!fs_extra_1.default.existsSync(filepath)) {
@@ -34,6 +35,7 @@ function joinAndProcessDir(options, ...args) {
     }
     return filepath;
 }
+exports.joinAndProcessDir = joinAndProcessDir;
 /** @internal */
 class FileManager {
     constructor() {
@@ -179,9 +181,15 @@ class FileManager {
     getRunMetaFile(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getCurDataDir(options), 'run-meta.json');
     }
+    getRunMetaExternalTemplateFile() {
+        return path_1.default.join(this.getCodeDataDir(), 'run-meta.json');
+    }
     getSnapshotSequenceMetaFile(options = FileManager.defaultFileOption) {
         return path_1.default.join(this.getCurDataDir(options), 'snap-seq.json');
     }
+    getSnapshotSequenceExternalTemplateFile() {
+        return path_1.default.join(this.getCodeDataDir(), 'visit-order.json');
+    }
     getInputDataDir() {
         return path_1.default.join(this.getDefaultWorkDir(), 'input');
     }
@@ -304,6 +312,9 @@ class FileManager {
         }
     }
     isDirectory(file) {
+        if (!fs_extra_1.default.existsSync(file)) {
+            return false;
+        }
         const stats = fs_extra_1.default.statSync(file);
         return stats.isDirectory();
     }
@@ -331,6 +342,41 @@ class FileManager {
         const internalDir = Constant_1.default.internalDir;
         return filePath.includes(`${sep}${internalDir}${sep}`);
     }
+    createDefaultVisitOrderMetaFile(options = FileManager.defaultFileOption) {
+        // if memlab/data/cur doesn't exist, return
+        const curDataDir = this.getCurDataDir(options);
+        if (!fs_extra_1.default.existsSync(curDataDir)) {
+            return;
+        }
+        // if the snap-seq.json file exists, return
+        const snapshotSeqMetaFile = this.getSnapshotSequenceMetaFile(options);
+        if (fs_extra_1.default.existsSync(snapshotSeqMetaFile)) {
+            return;
+        }
+        // if there is no .heapsnapshot file, return
+        const files = fs_extra_1.default.readdirSync(curDataDir);
+        const snapshotFile = files.find(file => file.endsWith('.heapsnapshot'));
+        if (snapshotFile == null) {
+            return;
+        }
+        // If there is at least one snapshot, create a snap-seq.json file.
+        // First, get the meta file for leak detection in a single heap snapshot
+        this.createDefaultVisitOrderMetaFileWithSingleSnapshot(options, snapshotFile);
+    }
+    createDefaultVisitOrderMetaFileWithSingleSnapshot(options = FileManager.defaultFileOption, snapshotFile) {
+        const snapshotSeqMetaFile = this.getSnapshotSequenceMetaFile(options);
+        const codeDataDir = this.getCodeDataDir();
+        const singleSnapshotMetaFile = path_1.default.join(codeDataDir, 'visit-order-single-snapshot.json');
+        const visitOrder = JSON.parse(fs_extra_1.default.readFileSync(singleSnapshotMetaFile, 'UTF-8'));
+        // fill in snapshot file name for each entry with snapshot: true
+        visitOrder.forEach(step => {
+            if (step.snapshot === true) {
+                step.snapshotFile = snapshotFile;
+            }
+        });
+        // save the snapshot meta file
+        fs_extra_1.default.writeFileSync(snapshotSeqMetaFile, JSON.stringify(visitOrder, null, 2), 'UTF-8');
+    }
     initDirs(config, options = FileManager.defaultFileOption) {
         // cache the last processed memlab config instance
         // the instance should be a singleton
@@ -339,6 +385,11 @@ class FileManager {
         // make sure getWorkDir is called first before
         // any other get file or get dir calls
         const workDir = this.getWorkDir(options);
+        // if errorWhenAbsent is set to true, make it
+        // an error when the working directory does not exist
+        if (options.errorWhenAbsent && !fs_extra_1.default.existsSync(workDir)) {
+            throw Utils_1.default.haltOrThrow(`work dir does not exist: ${workDir}`);
+        }
         // remember the current working directory
         // especially if this is a transcient working directory
         config.workDir = joinAndProcessDir(options, workDir);
@@ -376,15 +427,16 @@ class FileManager {
         config.heapAnalysisLogDir = joinAndProcessDir(options, this.getHeapAnalysisLogDir(options));
         config.metricsOutDir = joinAndProcessDir(options, loggerOutDir, 'metrics');
         config.reportScreenshotFile = path_1.default.join(outDir, 'report.png');
-        const codeDataDir = this.getCodeDataDir();
-        config.externalRunMetaFile = path_1.default.join(codeDataDir, 'run-meta.json');
-        config.externalSnapshotVisitOrderFile = path_1.default.join(codeDataDir, 'visit-order.json');
+        config.externalRunMetaFile = this.getRunMetaExternalTemplateFile();
+        config.externalSnapshotVisitOrderFile =
+            this.getSnapshotSequenceExternalTemplateFile();
         joinAndProcessDir(options, this.getUniqueTraceClusterDir(options));
         config.newUniqueClusterDir = joinAndProcessDir(options, this.getNewUniqueTraceClusterDir(options));
         config.staleUniqueClusterDir = joinAndProcessDir(options, this.getStaleUniqueTraceClusterDir(options));
         config.currentUniqueClusterDir = joinAndProcessDir(options, this.getExistingUniqueTraceClusterDir(options));
         config.unclassifiedClusterDir = joinAndProcessDir(options, this.getUnclassifiedTraceClusterDir(options));
         config.allClusterSummaryFile = this.getAllClusterSummaryFile(options);
+        this.createDefaultVisitOrderMetaFile(options);
     }
 }
 exports.FileManager = FileManager;

package/dist/lib/HeapAnalyzer.d.ts

@@ -16,6 +16,10 @@ declare type DiffSnapshotsOptions = {
 declare type WorkDirOptions = {
     workDir?: string;
 };
+declare type GetTraceOptions = {
+    workDir?: string;
+    printConsoleOnly?: boolean;
+};
 declare class MemoryAnalyst {
     checkLeak(): Promise<ISerializedInfo[]>;
     diffLeakByWorkDir(options: DiffLeakOptions): Promise<ISerializedInfo[]>;
@@ -50,7 +54,7 @@ declare class MemoryAnalyst {
     serializeClusterUpdate(clusters: TraceCluster[], options?: {
         reclusterOnly?: boolean;
     }): Promise<void>;
-    dumpPathByNodeId(leakedIdSet: HeapNodeIdSet, snapshot: IHeapSnapshot, nodeIdsInSnapshots: Array<HeapNodeIdSet>, id: number, pathLoaderFile: string, summaryFile: string, options?: WorkDirOptions): void;
+    dumpPathByNodeId(leakedIdSet: HeapNodeIdSet, snapshot: IHeapSnapshot, nodeIdsInSnapshots: Array<HeapNodeIdSet>, id: number, pathLoaderFile: string, summaryFile: string, options?: GetTraceOptions): void;
 }
 declare const _default: MemoryAnalyst;
 export default _default;

package/dist/lib/HeapAnalyzer.js

@@ -34,6 +34,7 @@ const TraceFinder_1 = __importDefault(require("../paths/TraceFinder"));
 const TraceBucket_1 = __importDefault(require("../trace-cluster/TraceBucket"));
 const LeakObjectFilter_1 = require("./leak-filters/LeakObjectFilter");
 const MLTraceSimilarityStrategy_1 = __importDefault(require("../trace-cluster/strategies/MLTraceSimilarityStrategy"));
+const LeakTraceFilter_1 = require("./trace-filters/LeakTraceFilter");
 class MemoryAnalyst {
     checkLeak() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -44,14 +45,14 @@ class MemoryAnalyst {
     }
     diffLeakByWorkDir(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const controlSnapshotDir = FileManager_1.default.getCurDataDir({
-                workDir: options.controlWorkDir,
-            });
+            const controlSnapshotDirs = options.controlWorkDirs.map(controlWorkDir => FileManager_1.default.getCurDataDir({
+                workDir: controlWorkDir,
+            }));
             const treatmentSnapshotDir = FileManager_1.default.getCurDataDir({
                 workDir: options.treatmentWorkDir,
             });
             // check control working dir
-            Utils_1.default.checkSnapshots({ snapshotDir: controlSnapshotDir });
+            controlSnapshotDirs.forEach(controlSnapshotDir => Utils_1.default.checkSnapshots({ snapshotDir: controlSnapshotDir }));
             // check treatment working dir
             Utils_1.default.checkSnapshots({ snapshotDir: treatmentSnapshotDir });
             // display control and treatment memory
@@ -63,31 +64,37 @@ class MemoryAnalyst {
     diffMemoryLeakTraces(options) {
         return __awaiter(this, void 0, void 0, function* () {
             Config_1.default.dumpNodeInfo = false;
-            // diff snapshots and get control raw paths
-            let snapshotDiff = yield this.diffSnapshots({
-                loadAllSnapshots: true,
-                workDir: options.controlWorkDir,
-            });
-            const controlLeakPaths = this.filterLeakPaths(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot, { workDir: options.controlWorkDir });
-            const controlSnapshot = snapshotDiff.snapshot;
+            // diff snapshots from control dirs and get control raw paths array
+            const controlSnapshots = [];
+            const leakPathsFromControlRuns = [];
+            for (const controlWorkDir of options.controlWorkDirs) {
+                const snapshotDiff = yield this.diffSnapshots({
+                    loadAllSnapshots: true,
+                    workDir: controlWorkDir,
+                });
+                leakPathsFromControlRuns.push(this.filterLeakPaths(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot, { workDir: controlWorkDir }));
+                controlSnapshots.push(snapshotDiff.snapshot);
+            }
             // diff snapshots and get treatment raw paths
-            snapshotDiff = yield this.diffSnapshots({
+            const snapshotDiff = yield this.diffSnapshots({
                 loadAllSnapshots: true,
                 workDir: options.treatmentWorkDir,
             });
-            const treatmentLeakPaths = this.filterLeakPaths(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot, { workDir: options.controlWorkDir });
+            const treatmentLeakPaths = this.filterLeakPaths(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot, { workDir: options.treatmentWorkDir });
             const treatmentSnapshot = snapshotDiff.snapshot;
-            Console_1.default.topLevel(`${controlLeakPaths.length} traces from control group`);
+            const controlPathCounts = JSON.stringify(leakPathsFromControlRuns.map(leakPaths => leakPaths.length));
+            Console_1.default.topLevel(`${controlPathCounts} traces from control group`);
             Console_1.default.topLevel(`${treatmentLeakPaths.length} traces from treatment group`);
-            const result = TraceBucket_1.default.clusterControlTreatmentPaths(controlLeakPaths, controlSnapshot, treatmentLeakPaths, treatmentSnapshot, Utils_1.default.aggregateDominatorMetrics, {
+            const result = TraceBucket_1.default.clusterControlTreatmentPaths(leakPathsFromControlRuns, controlSnapshots, treatmentLeakPaths, treatmentSnapshot, Utils_1.default.aggregateDominatorMetrics, {
                 strategy: Config_1.default.isMLClustering
                     ? new MLTraceSimilarityStrategy_1.default()
                     : undefined,
             });
             Console_1.default.midLevel(`MemLab found ${result.treatmentOnlyClusters.length} new leak(s) in the treatment group`);
             yield this.serializeClusterUpdate(result.treatmentOnlyClusters);
-            // TODO (lgong): log leak traces
-            return [];
+            // serialize JSON file with detailed leak trace information
+            const treatmentOnlyPaths = result.treatmentOnlyClusters.map(c => c.path);
+            return LeakTraceDetailsLogger_1.default.logTraces(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot, snapshotDiff.listOfLeakedHeapNodeIdSet, treatmentOnlyPaths, Config_1.default.traceJsonOutDir);
         });
     }
     // find all unique pattern of leaks
@@ -124,7 +131,7 @@ class MemoryAnalyst {
                 snapshotLeakedHeapNodeIdSet = snapshotDiff.leakedHeapNodeIdSet;
                 snapshot = snapshotDiff.snapshot;
             }
-            this.dumpPathByNodeId(snapshotLeakedHeapNodeIdSet, snapshot, nodeIdsInSnapshots, Config_1.default.focusFiberNodeId, Config_1.default.viewJsonFile, Config_1.default.singleReportSummary);
+            this.dumpPathByNodeId(snapshotLeakedHeapNodeIdSet, snapshot, nodeIdsInSnapshots, Config_1.default.focusFiberNodeId, Config_1.default.viewJsonFile, Config_1.default.singleReportSummary, { printConsoleOnly: true });
         });
     }
     shouldLoadCompleteSnapshot(tabsOrder, tab) {
@@ -348,6 +355,7 @@ class MemoryAnalyst {
         this.printHeapAndLeakInfo(leakedNodeIds, snapshot, options);
         // get all leaked objects
         this.filterLeakedObjects(leakedNodeIds, snapshot);
+        const leakTraceFilter = new LeakTraceFilter_1.LeakTraceFilter();
         const nodeIdInPaths = new Set();
         const paths = [];
         let numOfLeakedObjects = 0;
@@ -359,7 +367,8 @@ class MemoryAnalyst {
             }
             // BFS search for path from the leaked node to GC roots
             const p = finder.getPathToGCRoots(snapshot, node);
-            if (!p || !Utils_1.default.isInterestingPath(p)) {
+            if (p == null ||
+                !leakTraceFilter.filter(p, { config: Config_1.default, leakedNodeIds, snapshot })) {
                 return;
             }
             ++numOfLeakedObjects;
@@ -451,10 +460,13 @@ class MemoryAnalyst {
                 return;
             }
             LeakTraceDetailsLogger_1.default.logTrace(leakedIdSet, snapshot, nodeIdsInSnapshots, path, pathLoaderFile);
-            const tabsOrder = Utils_1.default.loadTabsOrder(FileManager_1.default.getSnapshotSequenceMetaFile(options));
-            const interactionSummary = Serializer_1.default.summarizeTabsOrder(tabsOrder);
             let pathSummary = Serializer_1.default.summarizePath(path, nodeIdInPaths, snapshot, { color: true });
             Console_1.default.topLevel(pathSummary);
+            if (options.printConsoleOnly) {
+                return;
+            }
+            const tabsOrder = Utils_1.default.loadTabsOrder(FileManager_1.default.getSnapshotSequenceMetaFile(options));
+            const interactionSummary = Serializer_1.default.summarizeTabsOrder(tabsOrder);
             pathSummary = Serializer_1.default.summarizePath(path, nodeIdInPaths, snapshot);
             const summary = `Page Interaction: \n${interactionSummary}\n\n` +
                 `Path from GC Root to Leaked Object:\n${pathSummary}`;

package/dist/lib/RunInfoUtils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+import type { Nullable, Optional, RunMetaInfo } from './Types';
+export declare class RunMetaInfoManager {
+    getRunMetaFilePath(options?: {
+        workDir?: Optional<string>;
+    }): string;
+    saveRunMetaInfo(runMetaInfo: RunMetaInfo, options?: {
+        workDir?: Optional<string>;
+        extraRunInfo?: Map<string, string>;
+    }): string;
+    private loadRunMetaInfoFromFile;
+    loadRunMetaInfo(options?: {
+        metaFile?: Optional<string>;
+        workDir?: Optional<string>;
+    }): RunMetaInfo;
+    loadRunMetaInfoSilentFail(options?: {
+        metaFile?: Optional<string>;
+        workDir?: Optional<string>;
+    }): Nullable<RunMetaInfo>;
+    loadRunMetaExternalTemplate(): RunMetaInfo;
+    setConfigFromRunMeta(options?: {
+        workDir?: Optional<string>;
+        silentFail?: boolean;
+    }): void;
+}
+declare const runInfoUtils: {
+    runMetaInfoManager: RunMetaInfoManager;
+};
+/** @internal */
+export default runInfoUtils;
+//# sourceMappingURL=RunInfoUtils.d.ts.map

package/dist/lib/RunInfoUtils.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunMetaInfoManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const BrowserInfo_1 = __importDefault(require("./BrowserInfo"));
+const Config_1 = __importDefault(require("./Config"));
+const Constant_1 = __importDefault(require("./Constant"));
+const FileManager_1 = __importDefault(require("./FileManager"));
+const Utils_1 = __importDefault(require("./Utils"));
+const InternalValueSetter_1 = require("./InternalValueSetter");
+class RunMetaInfoManager {
+    getRunMetaFilePath(options) {
+        if ((options === null || options === void 0 ? void 0 : options.workDir) != null) {
+            return FileManager_1.default.getRunMetaFile({ workDir: options.workDir });
+        }
+        if (Config_1.default.useExternalSnapshot) {
+            return Config_1.default.externalRunMetaFile;
+        }
+        if (Config_1.default.runMetaFile != null) {
+            return Config_1.default.runMetaFile;
+        }
+        return FileManager_1.default.getRunMetaFile();
+    }
+    saveRunMetaInfo(runMetaInfo, options) {
+        var _a;
+        const runMetaFile = this.getRunMetaFilePath(options);
+        const serializable = Object.assign(Object.assign({}, runMetaInfo), { extraInfo: Object.assign(Object.assign({}, Utils_1.default.mapToObject(Config_1.default.extraRunInfoMap)), Utils_1.default.mapToObject((_a = options === null || options === void 0 ? void 0 : options.extraRunInfo) !== null && _a !== void 0 ? _a : new Map())) });
+        fs_1.default.writeFileSync(runMetaFile, JSON.stringify(serializable, null, 2), 'UTF-8');
+        return runMetaFile;
+    }
+    loadRunMetaInfoFromFile(file) {
+        const content = fs_1.default.readFileSync(file, 'UTF-8');
+        const runMetaInfo = JSON.parse(content);
+        if (runMetaInfo && runMetaInfo.extraInfo) {
+            Config_1.default.extraRunInfoMap = Utils_1.default.objectToMap(runMetaInfo.extraInfo);
+        }
+        return runMetaInfo;
+    }
+    loadRunMetaInfo(options) {
+        const file = (options === null || options === void 0 ? void 0 : options.metaFile) || this.getRunMetaFilePath(options);
+        try {
+            return this.loadRunMetaInfoFromFile(file);
+        }
+        catch (_) {
+            throw Utils_1.default.haltOrThrow('Run info missing. Please make sure `memlab run` is complete.');
+        }
+    }
+    loadRunMetaInfoSilentFail(options) {
+        const file = (options === null || options === void 0 ? void 0 : options.metaFile) || this.getRunMetaFilePath(options);
+        try {
+            return this.loadRunMetaInfoFromFile(file);
+        }
+        catch (_) {
+            return null;
+        }
+    }
+    loadRunMetaExternalTemplate() {
+        const runMetaTemplateFile = FileManager_1.default.getRunMetaExternalTemplateFile();
+        return JSON.parse(fs_1.default.readFileSync(runMetaTemplateFile, 'UTF-8'));
+    }
+    setConfigFromRunMeta(options = {}) {
+        const meta = (options === null || options === void 0 ? void 0 : options.silentFail)
+            ? this.loadRunMetaInfoSilentFail(options)
+            : this.loadRunMetaInfo(options);
+        if (meta == null) {
+            return;
+        }
+        if ((meta === null || meta === void 0 ? void 0 : meta.app) == null || (meta === null || meta === void 0 ? void 0 : meta.interaction) == null) {
+            if (options === null || options === void 0 ? void 0 : options.silentFail) {
+                return;
+            }
+            throw Utils_1.default.haltOrThrow('No app or interaction infomation');
+        }
+        Config_1.default.targetApp = meta.app;
+        Config_1.default.targetTab = meta.interaction;
+        BrowserInfo_1.default.load(meta.browserInfo);
+    }
+}
+exports.RunMetaInfoManager = RunMetaInfoManager;
+const runInfoUtils = { runMetaInfoManager: new RunMetaInfoManager() };
+(0, InternalValueSetter_1.setInternalValue)(runInfoUtils, __filename, Constant_1.default.internalDir);
+/** @internal */
+exports.default = runInfoUtils;