@memlab/e2e 1.0.17 → 1.0.18

package/dist/BaseSynthesizer.d.ts

@@ -8,7 +8,7 @@
  * @lightSyntaxTransform
  * @oncall web_perf_infra
  */
-import type { AnyOptions, Config, E2EOperation, E2EStepInfo, IE2EScenarioVisitPlan, E2ESynthesizerOptions, IScenario, IE2EStepBasic, IE2EScenarioSynthesizer, CheckPageLoadCallback, Nullable } from '@memlab/core';
+import type { AnyOptions, Config, E2EOperation, E2EStepInfo, IE2EScenarioVisitPlan, E2ESynthesizerOptions, IScenario, IE2EStepBasic, IE2EScenarioSynthesizer, CheckPageLoadCallback, Nullable, PageSetupCallback } from '@memlab/core';
 declare class BaseSynthesizer implements IE2EScenarioSynthesizer {
     protected config: Config;
     protected steps: Map<string, IE2EStepBasic>;
@@ -41,6 +41,7 @@ declare class BaseSynthesizer implements IE2EScenarioSynthesizer {
     getDevice(): string;
     getExtraOperationsForStep(_stepInfo: E2EStepInfo): E2EOperation[];
     getPageLoadChecker(): CheckPageLoadCallback;
+    getPageSetupCallback(): PageSetupCallback;
     synthesis(baseline: string, target: string, intermediates: string[], options?: E2ESynthesizerOptions): IE2EScenarioVisitPlan;
     private getActualNumberOfWarmup;
     private synthesisInitPart;

package/dist/BaseSynthesizer.js

@@ -156,6 +156,12 @@ class BaseSynthesizer {
             return true;
         });
     }
+    getPageSetupCallback() {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        return (_page) => __awaiter(this, void 0, void 0, function* () {
+            return;
+        });
+    }
     synthesis(baseline, target, intermediates, options = {}) {
         const type = options.type;
         if (!type || type === 'standard') {
@@ -257,6 +263,7 @@ class BaseSynthesizer {
             numOfWarmup: this.getActualNumberOfWarmup(),
             dataBuilder: options.dataBuilder,
             isPageLoaded: this.getPageLoadChecker(),
+            pageSetup: this.getPageSetupCallback(),
         };
     }
     synthesisStandard(baseline, target, intermediates, options = {}) {
@@ -278,6 +285,7 @@ class BaseSynthesizer {
             numOfWarmup: this.getActualNumberOfWarmup(),
             dataBuilder: options.dataBuilder,
             isPageLoaded: this.getPageLoadChecker(),
+            pageSetup: this.getPageSetupCallback(),
         };
     }
     processStepUrl(url) {
@@ -335,6 +343,7 @@ class BaseSynthesizer {
             numOfWarmup: this.getActualNumberOfWarmup(),
             dataBuilder: null,
             isPageLoaded: (_a = scenario.isPageLoaded) !== null && _a !== void 0 ? _a : this.getPageLoadChecker(),
+            pageSetup: this.getPageSetupCallback(),
             scenario,
         };
     }
@@ -356,6 +365,7 @@ class BaseSynthesizer {
             numOfWarmup: this.getActualNumberOfWarmup(),
             dataBuilder: options.dataBuilder,
             isPageLoaded: this.getPageLoadChecker(),
+            pageSetup: this.getPageSetupCallback(),
         };
     }
     synthesisInitialPageLoad(target, intermediates, options = {}) {
@@ -381,6 +391,7 @@ class BaseSynthesizer {
             numOfWarmup: this.getActualNumberOfWarmup(),
             dataBuilder: options.dataBuilder,
             isPageLoaded: this.getPageLoadChecker(),
+            pageSetup: this.getPageSetupCallback(),
         };
     }
     getActionFromStep(step, type, snapshot, screenshot) {

package/dist/E2EInteractionManager.js

@@ -99,6 +99,9 @@ class E2EInteractionManager {
             yield setPermissions(this.page, TestPlanner_1.default.getOrigin());
             yield this.beforeInteractions();
             const baseURL = core_1.utils.normalizeBaseUrl(visitPlan.baseURL);
+            if (visitPlan.pageSetup) {
+                yield visitPlan.pageSetup(this.page);
+            }
             yield this.startTrackingHeap();
             for (let i = 0; i < visitPlan.tabsOrder.length; i++) {
                 core_1.info.beginSection(`step-${i}`);

package/dist/ScriptManager.d.ts

@@ -7,7 +7,9 @@
  * @format
  * @oncall web_perf_infra
  */
+import type { Nullable } from '@memlab/core';
 import type { RewriteScriptOption } from './instrumentation/ScriptRewriteManager';
+import type { ClosureScope } from './code-analysis/Script';
 export default class ScriptManager {
     private fileId;
     private metaFileWriteTimeout;
@@ -17,6 +19,8 @@ export default class ScriptManager {
     constructor();
     private init;
     loadFromFiles(): boolean;
+    loadCodeForUrl(url: string): Nullable<string>;
+    getClosureScopeTreeForUrl(url: string): Nullable<ClosureScope>;
     rewriteScript(code: string, options?: RewriteScriptOption): Promise<string>;
     logScript(url: string, code: string): Promise<void>;
     private debounce;

package/dist/ScriptManager.js

@@ -24,6 +24,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const core_1 = require("@memlab/core");
+const Script_1 = __importDefault(require("./code-analysis/Script"));
 const ScriptRewriteManager_1 = __importDefault(require("./instrumentation/ScriptRewriteManager"));
 class ScriptManager {
     constructor() {
@@ -47,9 +48,6 @@ class ScriptManager {
             const metaContent = fs_1.default.readFileSync(webSourceMetaFile, 'UTF-8');
             this.scriptInfos = JSON.parse(metaContent);
             for (const scriptInfo of this.scriptInfos) {
-                if (!fs_1.default.existsSync(scriptInfo.codePath)) {
-                    return false;
-                }
                 this.urlToScriptMap.set(scriptInfo.url, scriptInfo);
             }
         }
@@ -58,6 +56,37 @@ class ScriptManager {
         }
         return true;
     }
+    loadCodeForUrl(url) {
+        var _a;
+        if (!this.urlToScriptMap.has(url)) {
+            return null;
+        }
+        const scriptInfo = this.urlToScriptMap.get(url);
+        if (scriptInfo.code) {
+            return scriptInfo.code;
+        }
+        try {
+            scriptInfo.code = fs_1.default.readFileSync(scriptInfo.codePath, 'UTF-8');
+        }
+        catch (_b) {
+            // do nothing
+        }
+        return (_a = scriptInfo.code) !== null && _a !== void 0 ? _a : null;
+    }
+    getClosureScopeTreeForUrl(url) {
+        const code = this.loadCodeForUrl(url);
+        if (code == null) {
+            return null;
+        }
+        try {
+            const script = new Script_1.default(code);
+            return script.getClosureScopeTree();
+        }
+        catch (_a) {
+            // do nothing
+        }
+        return null;
+    }
     rewriteScript(code, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!core_1.config.instrumentJS) {
@@ -82,7 +111,7 @@ class ScriptManager {
             this.urlToScriptMap.set(url, scriptInfo);
             this.scriptInfos.push(scriptInfo);
             fs_1.default.writeFile(file, code, 'UTF-8', () => {
-                // write file asynchroniously
+                // async write, do nothing here
             });
             // only write the latest version of the meta file state
             this.debounce(() => {

package/dist/__tests__/scope/lib.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 { AnyValue } from '@memlab/core';
+export declare function testScopeAnalysis(code: string, expectedScope: AnyValue): void;
+export declare function removeLoc(entity: AnyValue): AnyValue;
+//# sourceMappingURL=lib.d.ts.map

package/dist/__tests__/scope/lib.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeLoc = exports.testScopeAnalysis = void 0;
+const Script_1 = __importDefault(require("../../code-analysis/Script"));
+function testScopeAnalysis(code, expectedScope) {
+    const script = new Script_1.default(code);
+    const scope = script.getClosureScopeTree();
+    expect(removeLoc(scope)).toEqual(removeLoc(expectedScope));
+}
+exports.testScopeAnalysis = testScopeAnalysis;
+function removeLoc(entity) {
+    const visited = new Set();
+    function remove(e) {
+        if (!e || typeof e !== 'object' || visited.has(e)) {
+            return;
+        }
+        visited.add(e);
+        for (const k of Object.keys(e)) {
+            if (k === 'loc') {
+                delete e.loc;
+            }
+            else {
+                remove(e[k]);
+            }
+        }
+    }
+    remove(entity);
+    return entity;
+}
+exports.removeLoc = removeLoc;

package/dist/__tests__/scope/scope-analysis.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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+export {};
+//# sourceMappingURL=scope-analysis.test.d.ts.map

package/dist/__tests__/scope/scope-analysis.test.js

@@ -0,0 +1,57 @@
+"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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+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 lib_1 = require("./lib");
+const code = `
+const v0 = 'abc';
+function f() {
+  const v1 = 'test';
+  function f2() {
+    let v2 = 123;
+    console.log(v0, v1, v2);
+  }
+}
+`;
+const closureScope = {
+    functionName: null,
+    functionType: 'Program',
+    nestedClosures: [
+        {
+            functionName: 'f',
+            functionType: 'FunctionDeclaration',
+            nestedClosures: [
+                {
+                    functionName: 'f2',
+                    functionType: 'FunctionDeclaration',
+                    nestedClosures: [],
+                    usedVariablesFromParentScope: ['v1'],
+                    variablesDefined: ['v2'],
+                },
+            ],
+            usedVariablesFromParentScope: ['v0'],
+            variablesDefined: ['v1', 'f2'],
+        },
+    ],
+    usedVariablesFromParentScope: [],
+    variablesDefined: ['v0', 'f'],
+};
+test('simple scope analysis works as expected', () => __awaiter(void 0, void 0, void 0, function* () {
+    (0, lib_1.testScopeAnalysis)(code, closureScope);
+}));

package/dist/code-analysis/Script.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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 { Optional } from '@memlab/core';
+import type { SourceLocation } from '@babel/types';
+export declare type ClosureScope = {
+    functionName: Optional<string>;
+    functionType: string;
+    variablesDefined: string[];
+    usedVariablesFromParentScope: string[];
+    nestedClosures: ClosureScope[];
+    loc: Optional<SourceLocation>;
+};
+export default class Script {
+    private code;
+    private ast;
+    private closureScopeTree;
+    constructor(code: string);
+    getClosureScopeTree(): ClosureScope;
+    private locToStr;
+    private findParentFunctionPath;
+    private findParentFunctionClosureScope;
+    private findGrandparentFunctionClosureScope;
+    private buildClosureScopeTree;
+}
+//# sourceMappingURL=Script.d.ts.map

package/dist/code-analysis/Script.js

@@ -0,0 +1,164 @@
+"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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const parser_1 = require("@babel/parser");
+const core_1 = require("@memlab/core");
+function isFunctionType(type) {
+    return (type === 'FunctionDeclaration' ||
+        type === 'FunctionExpression' ||
+        type === 'ObjectMethod' ||
+        type === 'ClassMethod' ||
+        type === 'ArrowFunctionExpression');
+}
+class Script {
+    constructor(code) {
+        this.code = code;
+        this.ast = (0, parser_1.parse)(code, {
+            sourceType: 'script',
+        });
+        this.closureScopeTree = this.buildClosureScopeTree(this.ast);
+    }
+    getClosureScopeTree() {
+        return this.closureScopeTree;
+    }
+    locToStr(loc) {
+        if (loc == null) {
+            throw core_1.utils.haltOrThrow(`location in ast is ${loc}`);
+        }
+        return JSON.stringify(loc);
+    }
+    findParentFunctionPath(path) {
+        let curPath = path.parentPath;
+        while (curPath) {
+            if (isFunctionType(curPath.node.type) ||
+                curPath.node.type === 'Program') {
+                return curPath;
+            }
+            if (curPath.parentPath == null) {
+                break;
+            }
+            curPath = curPath.parentPath;
+        }
+        return null;
+    }
+    findParentFunctionClosureScope(locToClosureScopeMap, path) {
+        const parentPath = this.findParentFunctionPath(path);
+        if (!parentPath) {
+            throw core_1.utils.haltOrThrow('cannot find parent scope');
+        }
+        const parentClosureScope = locToClosureScopeMap.get(this.locToStr(parentPath.node.loc));
+        if (!parentClosureScope) {
+            throw core_1.utils.haltOrThrow('cannot find parent scope');
+        }
+        return parentClosureScope;
+    }
+    findGrandparentFunctionClosureScope(locToClosureScopeMap, path) {
+        const parentPath = this.findParentFunctionPath(path);
+        if (!parentPath) {
+            throw core_1.utils.haltOrThrow('cannot find parent scope');
+        }
+        const grandparentPath = this.findParentFunctionPath(parentPath);
+        if (!grandparentPath) {
+            return null;
+        }
+        const grandparentClosureScope = locToClosureScopeMap.get(this.locToStr(grandparentPath.node.loc));
+        if (!grandparentClosureScope) {
+            throw core_1.utils.haltOrThrow('cannot find parent scope');
+        }
+        return grandparentClosureScope;
+    }
+    buildClosureScopeTree(ast) {
+        const root = {
+            functionName: null,
+            functionType: ast.program.type,
+            variablesDefined: [],
+            usedVariablesFromParentScope: [],
+            nestedClosures: [],
+            loc: ast.program.loc,
+        };
+        const locToClosureScopeMap = new Map();
+        locToClosureScopeMap.set(this.locToStr(ast.program.loc), root);
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        // build closure scope hierarchy
+        const buildClosureScopeFromFunction = function (path) {
+            var _a, _b;
+            const closureScope = {
+                functionName: 'id' in path.node ? (_b = (_a = path.node) === null || _a === void 0 ? void 0 : _a.id) === null || _b === void 0 ? void 0 : _b.name : null,
+                functionType: path.node.type,
+                variablesDefined: Object.keys(path.scope.bindings),
+                usedVariablesFromParentScope: [],
+                nestedClosures: [],
+                loc: path.node.loc,
+            };
+            locToClosureScopeMap.set(self.locToStr(path.node.loc), closureScope);
+            // find and connect to parent closure scope
+            const parentClosureScope = self.findParentFunctionClosureScope(locToClosureScopeMap, path);
+            parentClosureScope.nestedClosures.push(closureScope);
+        };
+        // Traverse the parent scope of the containing scope
+        // to find out if both of the conditions are true:
+        // 1. This is a var use in the containing scope
+        // 2. This is a var defined in the direct parent scope
+        //    of the containing scope
+        // If true, add the identifer name to the usedVariablesFromParentScope
+        // of the containing scope
+        const fillInVarInfo = function (path) {
+            // if the identifier is a function name of a function definition
+            if (isFunctionType(path.parentPath.node.type)) {
+                return;
+            }
+            const name = path.node.name;
+            let parentPath = self.findParentFunctionPath(path);
+            let parentClosureScope = parentPath
+                ? locToClosureScopeMap.get(self.locToStr(parentPath.node.loc))
+                : null;
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                if (!parentPath || !parentClosureScope) {
+                    break;
+                }
+                const grandparentPath = self.findParentFunctionPath(parentPath);
+                if (!grandparentPath) {
+                    break;
+                }
+                const grandparentClosureScope = locToClosureScopeMap.get(self.locToStr(grandparentPath.node.loc));
+                if (!grandparentClosureScope) {
+                    break;
+                }
+                if (grandparentClosureScope.variablesDefined.includes(name) &&
+                    !parentClosureScope.usedVariablesFromParentScope.includes(name)) {
+                    parentClosureScope.usedVariablesFromParentScope.push(name);
+                    break;
+                }
+                parentPath = grandparentPath;
+                parentClosureScope = grandparentClosureScope;
+            }
+        };
+        (0, traverse_1.default)(ast, {
+            FunctionDeclaration: buildClosureScopeFromFunction,
+            FunctionExpression: buildClosureScopeFromFunction,
+            ObjectMethod: buildClosureScopeFromFunction,
+            ClassMethod: buildClosureScopeFromFunction,
+            ArrowFunctionExpression: buildClosureScopeFromFunction,
+            Identifier: fillInVarInfo,
+            Program: (path) => {
+                root.variablesDefined = Object.keys(path.scope.bindings);
+            },
+        });
+        return root;
+    }
+}
+exports.default = Script;

package/dist/index.d.ts

@@ -15,4 +15,8 @@ export { default as Xvfb } from './lib/operations/XVirtualFrameBuffer';
 export { default as E2EInteractionManager } from './E2EInteractionManager';
 export { default as BaseSynthesizer } from './BaseSynthesizer';
 export { default as E2EUtils } from './lib/E2EUtils';
+/** @internal */
+export { default as ScriptManager } from './ScriptManager';
+/** @internal */
+export type { ClosureScope } from './code-analysis/Script';
 //# sourceMappingURL=index.d.ts.map

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.E2EUtils = exports.BaseSynthesizer = exports.E2EInteractionManager = exports.Xvfb = exports.defaultTestPlanner = exports.registerPackage = void 0;
+exports.ScriptManager = exports.E2EUtils = exports.BaseSynthesizer = exports.E2EInteractionManager = exports.Xvfb = exports.defaultTestPlanner = exports.registerPackage = void 0;
 const path_1 = __importDefault(require("path"));
 const core_1 = require("@memlab/core");
 /** @internal */
@@ -56,3 +56,6 @@ var BaseSynthesizer_1 = require("./BaseSynthesizer");
 Object.defineProperty(exports, "BaseSynthesizer", { enumerable: true, get: function () { return __importDefault(BaseSynthesizer_1).default; } });
 var E2EUtils_1 = require("./lib/E2EUtils");
 Object.defineProperty(exports, "E2EUtils", { enumerable: true, get: function () { return __importDefault(E2EUtils_1).default; } });
+/** @internal */
+var ScriptManager_1 = require("./ScriptManager");
+Object.defineProperty(exports, "ScriptManager", { enumerable: true, get: function () { return __importDefault(ScriptManager_1).default; } });

package/dist/instrumentation/BaseAstTransform.d.ts

@@ -7,10 +7,9 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { ParseResult } from '@babel/parser';
-import type { File } from '@babel/types';
+import type { ParseResult } from '@babel/core';
 import type { RewriteScriptOption } from './ScriptRewriteManager';
 export default abstract class BaseAstTransform {
-    transform(ast: ParseResult<File>, options?: RewriteScriptOption): Promise<void>;
+    transform(ast: ParseResult, options?: RewriteScriptOption): Promise<void>;
 }
 //# sourceMappingURL=BaseAstTransform.d.ts.map

package/dist/instrumentation/transforms/InjectSourceInfoTranform.d.ts

@@ -1,17 +1,7 @@
-/**
- * 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 { File } from '@babel/types';
-import type { ParseResult } from '@babel/parser';
+import type { ParseResult } from '@babel/core';
 import type { RewriteScriptOption } from '../ScriptRewriteManager';
 import BaseAstTransform from '../BaseAstTransform';
 export default class InjectSourceInfoTranform extends BaseAstTransform {
-    transform(ast: ParseResult<File>, options?: RewriteScriptOption): Promise<void>;
+    transform(ast: ParseResult, options?: RewriteScriptOption): Promise<void>;
 }
 //# sourceMappingURL=InjectSourceInfoTranform.d.ts.map

package/dist/instrumentation/transforms/InjectSourceInfoTransform.d.ts

@@ -1,17 +1,7 @@
-/**
- * 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 { File } from '@babel/types';
-import type { ParseResult } from '@babel/parser';
+import type { ParseResult } from '@babel/core';
 import type { RewriteScriptOption } from '../ScriptRewriteManager';
 import BaseAstTransform from '../BaseAstTransform';
 export default class InjectSourceInfoTransform extends BaseAstTransform {
-    transform(ast: ParseResult<File>, options?: RewriteScriptOption): Promise<void>;
+    transform(ast: ParseResult, options?: RewriteScriptOption): Promise<void>;
 }
 //# sourceMappingURL=InjectSourceInfoTransform.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memlab/e2e",
-  "version": "1.0.17",
+  "version": "1.0.18",
   "license": "MIT",
   "description": "memlab browser E2E interaction libraries",
   "author": "Liang Gong <lgong@fb.com>",
@@ -55,7 +55,8 @@
   },
   "scripts": {
     "build-pkg": "tsc",
-    "publish-patch": "npm version patch --force && npm publish",
+    "test-pkg": "jest .",
+    "publish-patch": "npm publish",
     "clean-pkg": "rm -rf ./dist && rm -rf ./node_modules && rm -f ./tsconfig.tsbuildinfo"
   },
   "bugs": {