@memlab/e2e 1.0.0

package/dist/lib/operations/ClickOperation.js

@@ -0,0 +1,131 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@memlab/core");
+const BaseOperation_1 = __importDefault(require("./BaseOperation"));
+const InteractionUtils_1 = __importDefault(require("./InteractionUtils"));
+class ClickOperation extends BaseOperation_1.default {
+    constructor(selector, args = {}) {
+        super();
+        this.kind = 'click';
+        this.selector = selector;
+        this.delay = args.delay;
+        this.optional = !!args.optional;
+        this.waitFor = args.waitFor;
+        this.clickCount = args.clickCount;
+        this.indexInMatches = args.indexInMatches;
+        // Takes a selector (string) to check if the selector is present or takes
+        // a function and evaluates that function to conditionally do the click
+        // operation
+        this.if = args.if;
+    }
+    _shouldClick(page) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.if == null) {
+                return true;
+            }
+            let shouldClick;
+            if (typeof this.if === 'string') {
+                const element = yield page.$(this.if);
+                shouldClick = !!element;
+                if (element != null) {
+                    yield element.dispose();
+                }
+            }
+            else if (typeof this.if === 'function') {
+                shouldClick = yield this.if(page);
+            }
+            else {
+                throw core_1.utils.haltOrThrow(`ClickOperation: 'if' must be a string or function`);
+            }
+            return shouldClick;
+        });
+    }
+    useContains() {
+        return this.selector.startsWith('contains:');
+    }
+    // click element with specified settings
+    clickElement(page) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const clickCount = this.clickCount || 1;
+            if (!this.useContains() && this.indexInMatches == null) {
+                yield page.click(this.selector, { clickCount });
+                return;
+            }
+            let elems;
+            // if given a special contains-text selector
+            if (this.useContains()) {
+                const text = this.selector.slice('contains:'.length);
+                elems = yield InteractionUtils_1.default.getElementsContainingText(page, text);
+            }
+            else {
+                elems = yield page.$$(this.selector);
+            }
+            if (!elems || elems.length === 0) {
+                core_1.utils.haltOrThrow(`selector not found: ${this.selector}`);
+            }
+            let idx = this.indexInMatches != null ? this.indexInMatches : 0;
+            if (idx < 0) {
+                idx = elems.length + idx;
+            }
+            if (idx < 0 || idx >= elems.length) {
+                core_1.utils.haltOrThrow(`clicking ${idx + 1}-th element, which doesn't exist`);
+            }
+            yield elems[idx].click({ clickCount });
+            yield Promise.all(elems.map(e => e.dispose()));
+        });
+    }
+    act(page) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const shouldClick = yield this._shouldClick(page);
+            if (!shouldClick) {
+                return;
+            }
+            const present = yield InteractionUtils_1.default.checkIfPresent(page, this.selector, this.optional);
+            if (!present) {
+                if (!this.optional) {
+                    core_1.utils.haltOrThrow(`Cannot find element ${this.selector}`);
+                }
+                return; // if optional element is not found
+            }
+            this.log(`clicking ${this.selector}`);
+            yield this.clickElement(page);
+            // extra delay
+            const delay = this.delay != null ? this.delay : core_1.config.defaultAfterClickDelay;
+            yield InteractionUtils_1.default.waitFor(delay);
+            // waiting for elements
+            if (this.waitFor != null) {
+                if (typeof this.waitFor === 'string') {
+                    yield InteractionUtils_1.default.waitForSelector(page, this.waitFor, 'exist', this.optional);
+                }
+                else if (typeof this.waitFor === 'function') {
+                    yield this.waitFor(page);
+                }
+                else {
+                    core_1.info.error(`ClickOperation: 'waitFor' must be a string or function`);
+                }
+            }
+        });
+    }
+}
+exports.default = ClickOperation;

package/dist/lib/operations/CompoundOperation.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import { Page } from 'puppeteer';
+import type { E2EOperation } from '@memlab/core';
+import BaseOperation from './BaseOperation';
+declare class CompoundOperation extends BaseOperation {
+    kind: string;
+    protected operations: E2EOperation[];
+    constructor(operations?: never[]);
+    act(page: Page): Promise<void>;
+}
+export default CompoundOperation;
+//# sourceMappingURL=CompoundOperation.d.ts.map

package/dist/lib/operations/CompoundOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompoundOperation.d.ts","sourceRoot":"","sources":["../../../src/lib/operations/CompoundOperation.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAC/B,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,cAAc,CAAC;AAC/C,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAE5C,cAAM,iBAAkB,SAAQ,aAAa;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC;gBACzB,UAAU,UAAK;IAMrB,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAKrC;AAED,eAAe,iBAAiB,CAAC"}

package/dist/lib/operations/CompoundOperation.js

@@ -0,0 +1,39 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseOperation_1 = __importDefault(require("./BaseOperation"));
+class CompoundOperation extends BaseOperation_1.default {
+    constructor(operations = []) {
+        super();
+        this.kind = 'compound';
+        this.operations = operations;
+    }
+    act(page) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const op of this.operations) {
+                yield op.act(page);
+            }
+        });
+    }
+}
+exports.default = CompoundOperation;

package/dist/lib/operations/EnterOperation.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import { Page } from 'puppeteer';
+import BaseOperation from './BaseOperation';
+declare class EnterOperation extends BaseOperation {
+    kind: string;
+    constructor();
+    act(page: Page): Promise<void>;
+}
+export default EnterOperation;
+//# sourceMappingURL=EnterOperation.d.ts.map

package/dist/lib/operations/EnterOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnterOperation.d.ts","sourceRoot":"","sources":["../../../src/lib/operations/EnterOperation.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAC/B,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAE5C,cAAM,cAAe,SAAQ,aAAa;IACxC,IAAI,EAAE,MAAM,CAAC;;IAMP,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAGrC;AAED,eAAe,cAAc,CAAC"}

package/dist/lib/operations/EnterOperation.js

@@ -0,0 +1,36 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseOperation_1 = __importDefault(require("./BaseOperation"));
+class EnterOperation extends BaseOperation_1.default {
+    constructor() {
+        super();
+        this.kind = 'enter';
+    }
+    act(page) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield page.keyboard.press('Enter');
+        });
+    }
+}
+exports.default = EnterOperation;

package/dist/lib/operations/EscOperation.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import BaseOperation from './BaseOperation';
+import type { Page } from 'puppeteer';
+export default class EscOperation extends BaseOperation {
+    kind: string;
+    constructor();
+    act(page: Page): Promise<void>;
+}
+//# sourceMappingURL=EscOperation.d.ts.map

package/dist/lib/operations/EscOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EscOperation.d.ts","sourceRoot":"","sources":["../../../src/lib/operations/EscOperation.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAEpC,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,aAAa;IACrD,IAAI,EAAE,MAAM,CAAC;;IAOP,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAGrC"}

package/dist/lib/operations/EscOperation.js

@@ -0,0 +1,36 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseOperation_1 = __importDefault(require("./BaseOperation"));
+class EscOperation extends BaseOperation_1.default {
+    constructor() {
+        super();
+        this.kind = 'escape';
+    }
+    act(page) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield page.keyboard.press('Escape');
+        });
+    }
+}
+exports.default = EscOperation;

package/dist/lib/operations/HoverOperation.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import { Page } from 'puppeteer';
+import type { Optional } from '@memlab/core';
+import BaseOperation from './BaseOperation';
+declare type HoverOptions = {
+    delay?: number;
+    optional?: boolean;
+    indexInMatches?: number;
+};
+declare class HoverOperation extends BaseOperation {
+    kind: string;
+    selector: string;
+    delay: Optional<number>;
+    indexInMatches: Optional<number>;
+    constructor(selector: string, args?: HoverOptions);
+    private hoverOverElement;
+    act(page: Page): Promise<void>;
+}
+export default HoverOperation;
+//# sourceMappingURL=HoverOperation.d.ts.map

package/dist/lib/operations/HoverOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HoverOperation.d.ts","sourceRoot":"","sources":["../../../src/lib/operations/HoverOperation.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAE/B,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,cAAc,CAAC;AAC3C,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAG5C,aAAK,YAAY,GAAG;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,cAAM,cAAe,SAAQ,aAAa;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACxB,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;gBACrB,QAAQ,EAAE,MAAM,EAAE,IAAI,GAAE,YAAiB;YAUvC,gBAAgB;IAyBxB,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAcrC;AAED,eAAe,cAAc,CAAC"}

package/dist/lib/operations/HoverOperation.js

@@ -0,0 +1,73 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@memlab/core");
+const BaseOperation_1 = __importDefault(require("./BaseOperation"));
+const InteractionUtils_1 = __importDefault(require("./InteractionUtils"));
+class HoverOperation extends BaseOperation_1.default {
+    constructor(selector, args = {}) {
+        super();
+        this.kind = 'hover';
+        this.selector = selector;
+        this.delay = args.delay;
+        this.optional = !!args.optional;
+        this.indexInMatches = args.indexInMatches;
+    }
+    // hover over element with specified settings
+    hoverOverElement(page) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.indexInMatches == null) {
+                yield page.hover(this.selector);
+                return;
+            }
+            const elems = yield page.$$(this.selector);
+            if (!elems || elems.length === 0) {
+                core_1.utils.haltOrThrow(`selector not found: ${this.selector}`);
+            }
+            let idx = this.indexInMatches;
+            if (idx < 0) {
+                idx = elems.length + idx;
+            }
+            if (idx < 0 || idx >= elems.length) {
+                core_1.utils.haltOrThrow(`hovering over ${idx + 1}-th element, which doesn't exist`);
+            }
+            yield elems[idx].hover();
+            yield Promise.all(elems.map(e => e.dispose()));
+        });
+    }
+    act(page) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const present = yield InteractionUtils_1.default.checkIfPresent(page, this.selector);
+            if (!present && !this.optional) {
+                core_1.utils.haltOrThrow(`Cannot find element ${this.selector}`);
+            }
+            if (present) {
+                this.log(`hovering over ${this.selector}`);
+                yield this.hoverOverElement(page);
+                const delay = this.delay != null ? this.delay : core_1.config.defaultAfterClickDelay;
+                yield InteractionUtils_1.default.waitFor(delay);
+            }
+        });
+    }
+}
+exports.default = HoverOperation;

package/dist/lib/operations/InteractionUtils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { Page, ElementHandle } from 'puppeteer';
+import type { CheckPageLoadCallback, OperationArgs } from '@memlab/core';
+declare function waitFor(delay: number): Promise<void>;
+declare function WaitUntilCallbackReturnsTrue(page: Page, isPageLoaded: CheckPageLoadCallback, options?: OperationArgs): Promise<void>;
+declare function waitUntilLoaded(page: Page, options?: OperationArgs): Promise<void>;
+declare function screenshot(page: Page, name: string | number): Promise<void>;
+declare function waitForSelector(page: Page, selector: string, whatToWaitForSelectorToDo?: string, optional?: boolean): Promise<boolean>;
+declare function checkIfPresent(page: Page, selector: string, optional?: boolean): Promise<boolean>;
+declare function checkIfVisible(page: Page, selector: string, optional?: boolean): Promise<boolean>;
+declare function waitForDisappearance(page: Page, selector: string, optional?: boolean): Promise<boolean>;
+declare function getElementsContainingText(page: Page, text: string): Promise<ElementHandle<Element>[]>;
+declare const _default: {
+    checkIfPresent: typeof checkIfPresent;
+    checkIfVisible: typeof checkIfVisible;
+    getElementsContainingText: typeof getElementsContainingText;
+    screenshot: typeof screenshot;
+    waitFor: typeof waitFor;
+    waitForDisappearance: typeof waitForDisappearance;
+    waitForSelector: typeof waitForSelector;
+    WaitUntilCallbackReturnsTrue: typeof WaitUntilCallbackReturnsTrue;
+    waitUntilLoaded: typeof waitUntilLoaded;
+};
+export default _default;
+//# sourceMappingURL=InteractionUtils.d.ts.map

package/dist/lib/operations/InteractionUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InteractionUtils.d.ts","sourceRoot":"","sources":["../../../src/lib/operations/InteractionUtils.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH,OAAO,KAAK,EAAC,IAAI,EAAE,aAAa,EAAC,MAAM,WAAW,CAAC;AACnD,OAAO,KAAK,EAAC,qBAAqB,EAAE,aAAa,EAAC,MAAM,cAAc,CAAC;AAEvE,iBAAS,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI7C;AAED,iBAAe,4BAA4B,CACzC,IAAI,EAAE,IAAI,EACV,YAAY,EAAE,qBAAqB,EACnC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,IAAI,CAAC,CA8Cf;AAED,iBAAe,eAAe,CAC5B,IAAI,EAAE,IAAI,EACV,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAwBf;AAED,iBAAe,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAO1E;AASD,iBAAe,eAAe,CAC5B,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,yBAAyB,SAAU,EACnC,QAAQ,UAAQ,GACf,OAAO,CAAC,OAAO,CAAC,CAyClB;AAmBD,iBAAe,cAAc,CAC3B,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,QAAQ,UAAQ,GACf,OAAO,CAAC,OAAO,CAAC,CAElB;AAED,iBAAe,cAAc,CAC3B,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,QAAQ,UAAQ,GACf,OAAO,CAAC,OAAO,CAAC,CAElB;AAED,iBAAe,oBAAoB,CACjC,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,QAAQ,UAAQ,GACf,OAAO,CAAC,OAAO,CAAC,CAElB;AAED,iBAAe,yBAAyB,CACtC,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE,CAAC,CAInC;;;;;;;;;;;;AAED,wBAUE"}

package/dist/lib/operations/InteractionUtils.js

@@ -0,0 +1,207 @@
+/**
+ * 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
+ */
+'use strict';
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@memlab/core");
+const path_1 = __importDefault(require("path"));
+function waitFor(delay) {
+    return new Promise(resolve => {
+        setTimeout(resolve, delay);
+    });
+}
+function WaitUntilCallbackReturnsTrue(page, isPageLoaded, options = {}) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        if (options.showProgress) {
+            core_1.info.overwrite('waiting for page load...');
+        }
+        let isSuccessful = false;
+        const failedURLs = (_a = options.failedURLs) !== null && _a !== void 0 ? _a : Object.create(null);
+        const url = new URL(page.url());
+        if (failedURLs[url.pathname]) {
+            return yield waitFor(core_1.config.delayWhenNoPageLoadCheck);
+        }
+        // retry check for at most 10 minutes
+        for (let i = 0; i < 10 * 60 * 50; ++i) {
+            // now check
+            let doneOrError;
+            try {
+                doneOrError = yield isPageLoaded(page);
+            }
+            catch (_b) {
+                break;
+            }
+            // if Check succeed
+            if (doneOrError === true) {
+                isSuccessful = true;
+                break;
+            }
+            else if (typeof doneOrError === 'string') {
+                // if error during page load check
+                return core_1.info.warning(`Checking page load got: ${doneOrError}`);
+            }
+            // Check page load is not successful yet, check again
+            yield waitFor(200);
+        }
+        if (!isSuccessful) {
+            if (!options.mute) {
+                core_1.info.overwrite(`Check timeout '${url.pathname}' set wait: ${core_1.config.delayWhenNoPageLoadCheck}ms`);
+            }
+            failedURLs[url.pathname] = true;
+        }
+        if (!options.noWaitAfterPageLoad) {
+            yield waitFor(core_1.config.waitAfterPageLoad);
+        }
+    });
+}
+function waitUntilLoaded(page, options = {}) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        // manual delay supercedes page load checker
+        let delay = (_a = options.delay) !== null && _a !== void 0 ? _a : 0;
+        if (delay > 0) {
+            if (!options.mute && delay > 2000) {
+                core_1.info.overwrite(`wait for ${delay / 1000}s`);
+            }
+            yield waitFor(delay);
+            return;
+        }
+        // check page load with specified checker
+        const isPageLoaded = options.isPageLoaded;
+        if (isPageLoaded) {
+            yield WaitUntilCallbackReturnsTrue(page, isPageLoaded, options);
+            return;
+        }
+        // if nothing is specified, use default delay
+        delay = core_1.config.delayWhenNoPageLoadCheck;
+        if (!options.mute && delay > 2000) {
+            core_1.info.overwrite(`wait for ${delay / 1000}s`);
+        }
+        yield waitFor(delay);
+    });
+}
+function screenshot(page, name) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (core_1.config.isContinuousTest) {
+            return;
+        }
+        const screenshotFile = path_1.default.join(core_1.config.curDataDir, `screenshot-${name}.png`);
+        core_1.info.overwrite('taking screenshot...');
+        yield page.screenshot({ path: screenshotFile });
+    });
+}
+function getWaitTimeout(optional) {
+    if (optional) {
+        return 3000;
+    }
+    return core_1.config.presenceCheckTimeout || 60000;
+}
+function waitForSelector(page, selector, whatToWaitForSelectorToDo = 'exist', optional = false) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const timeout = getWaitTimeout(optional);
+        let waitConfig = null;
+        switch (whatToWaitForSelectorToDo) {
+            case 'appear':
+                waitConfig = {
+                    visible: true, // ie. not `display:none` or `visibility:hidden`
+                };
+                break;
+            case 'disappear':
+                waitConfig = {
+                    hidden: true, // ie. `display:none`, `visibility:hidden`, or removed
+                };
+                break;
+            case 'exist': // ie. existent, whether visible or not; default config.
+                break;
+        }
+        core_1.info.overwrite(`wait for ${selector} to ${whatToWaitForSelectorToDo}`);
+        if (selector.startsWith('contains:')) {
+            return yield keepTryingUntil(() => __awaiter(this, void 0, void 0, function* () {
+                const text = selector.slice('contains:'.length);
+                const elems = yield getElementsContainingText(page, text);
+                if (!elems || elems.length === 0) {
+                    return false;
+                }
+                yield Promise.all(elems.map(e => e.dispose()));
+                return true;
+            }), timeout);
+        }
+        try {
+            const elem = yield page.waitForSelector(selector, Object.assign(Object.assign({}, waitConfig), { timeout }));
+            if (elem) {
+                yield elem.dispose();
+            }
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+function keepTryingUntil(checkCallback, timeout = 2000) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const startTimestamp = Date.now();
+        let currentTimestamp = Date.now();
+        while (currentTimestamp - startTimestamp < timeout) {
+            const flag = yield checkCallback();
+            if (flag) {
+                return true;
+            }
+            yield waitFor(200);
+            currentTimestamp = Date.now();
+        }
+        return false;
+    });
+}
+function checkIfPresent(page, selector, optional = false) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return waitForSelector(page, selector, 'exist', optional);
+    });
+}
+function checkIfVisible(page, selector, optional = false) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return waitForSelector(page, selector, 'appear', optional);
+    });
+}
+function waitForDisappearance(page, selector, optional = false) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return waitForSelector(page, selector, 'disappear', optional);
+    });
+}
+function getElementsContainingText(page, text) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const xpath = `//*[not(self::script)][contains(text(), '${text}')]`;
+        const elements = yield page.$x(xpath);
+        return elements;
+    });
+}
+exports.default = {
+    checkIfPresent,
+    checkIfVisible,
+    getElementsContainingText,
+    screenshot,
+    waitFor,
+    waitForDisappearance,
+    waitForSelector,
+    WaitUntilCallbackReturnsTrue,
+    waitUntilLoaded,
+};