@auxcode/auxta 0.5.5 → 0.5.9

package/build/cjs/auxta/services/report.service.js

@@ -0,0 +1,162 @@
+"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 });
+exports.postNotificationsOnFail = exports.postNotifications = exports.getLastDayResults = exports.getReport = exports.updateReport = exports.uploadFeature = exports.uploadScenario = exports.createEmptyReport = void 0;
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../configs/config");
+function headers(token) {
+    return {
+        headers: {
+            'Content-Type': 'application/json',
+            'cookie': `authToken=${token}`
+        }
+    };
+}
+function auth() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return axios_1.default.post(config_1.config.auxtaURL + 'login', config_1.config.auxtaCredentials, {
+            headers: {
+                'Content-Type': 'application/json',
+            }
+        })
+            .then(({ data }) => {
+            return data.token;
+        })
+            .catch(() => {
+            throw new Error("Invalid login credentials");
+        });
+    });
+}
+function createEmptyReport(body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = yield auth();
+        return (yield axios_1.default.post(config_1.config.auxtaURL + "create-empty-report", {
+            environment: body.environment,
+            digitalProductName: body.digitalProduct,
+            start: new Date(),
+            url: body.baseUrl
+        }, headers(token))).data.reportId;
+    });
+}
+exports.createEmptyReport = createEmptyReport;
+function uploadScenario(stepLog, scenarioName, screenshot, errMessage) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let scenarios = [];
+        let token = yield auth();
+        let lastStep = stepLog[stepLog.length - 1];
+        const stepLogFormat = JSON.parse(JSON.stringify(stepLog));
+        stepLogFormat.pop();
+        let output = (yield axios_1.default.post(config_1.config.auxtaURL + "create-scenario", {
+            json: {
+                name: scenarioName,
+                steps: [
+                    ...stepLogFormat,
+                    (lastStep.result.status == 'failed')
+                        ? Object.assign(lastStep, {
+                            result: Object.assign(Object.assign({}, lastStep.result), { error_message: JSON.stringify(errMessage) })
+                        })
+                        : lastStep,
+                    {
+                        keyword: "After",
+                        result: {
+                            status: "passed",
+                            duration: 2678000000
+                        },
+                        embeddings: (screenshot) ? [{
+                                data: screenshot.toString("base64"),
+                                mime_type: "image/png"
+                            }] : undefined,
+                    }
+                ],
+            }
+        }, headers(token))).data.scenarios;
+        scenarios.push({
+            scenarioRef: output.scenarioRef,
+            name: output.name,
+            status: output.status,
+            stepsCount: output.stepsCount
+        });
+        return scenarios;
+    });
+}
+exports.uploadScenario = uploadScenario;
+function uploadFeature(scenarioId, scenarioName, uri, hasFailed) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        return (yield axios_1.default.post(config_1.config.auxtaURL + "create-feature", {
+            json: {
+                name: scenarioName,
+                uri: uri
+            },
+            scenarios: scenarioId,
+            hasFailed: hasFailed
+        }, headers(token))).data;
+    });
+}
+exports.uploadFeature = uploadFeature;
+function updateReport(reportId, feature, steps, isFinal) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        yield axios_1.default.post(config_1.config.auxtaURL + "update-inprogress-report", {
+            reportId: reportId,
+            isFinal: isFinal,
+            data: Object.assign({ feature: {
+                    featureRef: feature.featureId,
+                    name: feature.featureName,
+                    uri: feature.featureUri,
+                    status: feature.status,
+                    scenariosCount: feature.scenariosCount
+                } }, steps)
+        }, headers(token));
+    });
+}
+exports.updateReport = updateReport;
+function getReport(reportId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        return (yield axios_1.default.post(config_1.config.auxtaURL + "get-report", { reportId: reportId }, headers(token))).data;
+    });
+}
+exports.getReport = getReport;
+function getLastDayResults() {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        return (yield axios_1.default.get(config_1.config.auxtaURL + `get-last-day-results?url=${config_1.config.baseURL}`, headers(token))).data.results;
+    });
+}
+exports.getLastDayResults = getLastDayResults;
+function postNotifications(body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        yield axios_1.default.post(`${config_1.config.auxtaURL}post-notification-after-run-background`, {
+            environmentName: body.environment,
+            digitalProductName: body.digitalProduct,
+            organizationName: body.organization,
+            reportId: body.reportId,
+        }, headers(token));
+    });
+}
+exports.postNotifications = postNotifications;
+function postNotificationsOnFail(body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        yield axios_1.default.post(`${config_1.config.auxtaURL}post-notifications-after-case-fail-background`, {
+            environmentName: body.environment,
+            digitalProductName: body.digitalProduct,
+            organizationName: body.organization,
+            reportId: body.reportId,
+        }, headers(token));
+    });
+}
+exports.postNotificationsOnFail = postNotificationsOnFail;

package/build/cjs/auxta/services/runtime.service.d.ts

@@ -0,0 +1,16 @@
+export interface RunTime {
+    duration: String;
+    startTime: Date;
+    endTime: Date;
+}
+export declare class Runtime {
+    private start;
+    private end;
+    private runtime;
+    constructor(s: Date, e: Date);
+    private calculateDuration;
+    private splitAtDecimanlMinutes;
+    private splitAtDecimanlHours;
+    private formatRuntime;
+    returnRuntime(): RunTime;
+}

package/build/cjs/auxta/services/runtime.service.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Runtime = void 0;
+class Runtime {
+    constructor(s, e) {
+        this.start = s;
+        this.end = e;
+    }
+    calculateDuration() {
+        let currentTime = new Date;
+        let duration = currentTime.getTime() - this.start.getTime();
+        return duration;
+    }
+    splitAtDecimanlMinutes(time) {
+        let minutes = time.toFixed(2).toString().split('.');
+        return `${minutes[0]}m ${(Number(minutes[1]) / 100 * 60).toFixed(0)}s`;
+    }
+    splitAtDecimanlHours(time) {
+        let hours = time.toFixed(2).toString().split('.');
+        let minutes = (Number(hours[1]) / 100 * 60).toFixed(2).toString().split('.');
+        return `${hours[0]}h ${minutes[0]}m ${(Number(minutes[1]) / 100 * 60).toFixed(0)}s`;
+    }
+    formatRuntime(duration) {
+        if (duration / 1000 < 60)
+            return `${(duration / 1000).toFixed(0)}s`;
+        else {
+            if (duration / 60000 < 60)
+                return this.splitAtDecimanlMinutes(duration / 60000);
+            else
+                return this.splitAtDecimanlHours(duration / 3600000);
+        }
+    }
+    returnRuntime() {
+        let duration = this.formatRuntime(this.calculateDuration());
+        let startTime = this.start;
+        let endTime = this.end;
+        this.runtime = { duration, startTime, endTime };
+        return this.runtime;
+    }
+}
+exports.Runtime = Runtime;

package/build/cjs/auxta/utilities/runtime.helper.d.ts

@@ -0,0 +1,15 @@
+import { RunTime } from "../services/runtime.service";
+export declare class CalculateRuntime {
+    private runtime;
+    startTimeSeconds: string;
+    startTimeMinutes: string;
+    startTimeHours: string;
+    startTimeDay: string;
+    startTimeMonth: string;
+    endTimeSeconds: string;
+    endTimeMinutes: string;
+    endTimeHours: string;
+    endTimeDay: string;
+    endTimeMonth: string;
+    constructor(r: RunTime);
+}

package/build/cjs/auxta/utilities/runtime.helper.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalculateRuntime = void 0;
+class CalculateRuntime {
+    constructor(r) {
+        this.runtime = r;
+        this.startTimeSeconds = (this.runtime.startTime.getSeconds() < 10) ? `0${this.runtime.startTime.getSeconds()}` : `${this.runtime.startTime.getSeconds()}`;
+        this.startTimeMinutes = (this.runtime.startTime.getMinutes() < 10) ? `0${this.runtime.startTime.getMinutes()}` : `${this.runtime.startTime.getMinutes()}`;
+        this.startTimeHours = (this.runtime.startTime.getHours() < 10) ? `0${this.runtime.startTime.getHours()}` : `${this.runtime.startTime.getHours()}`;
+        this.startTimeDay = (this.runtime.startTime.getDate() < 10) ? `0${this.runtime.startTime.getDate()}` : `${this.runtime.startTime.getDate()}`;
+        this.startTimeMonth = (this.runtime.startTime.getMonth() + 1 < 10) ? `0${this.runtime.startTime.getMonth() + 1}` : `${this.runtime.startTime.getMonth() + 1}`;
+        this.endTimeSeconds = (this.runtime.endTime.getSeconds() < 10) ? `0${this.runtime.endTime.getSeconds()}` : `${this.runtime.endTime.getSeconds()}`;
+        this.endTimeMinutes = (this.runtime.endTime.getMinutes() < 10) ? `0${this.runtime.endTime.getMinutes()}` : `${this.runtime.endTime.getMinutes()}`;
+        this.endTimeHours = (this.runtime.endTime.getHours() < 10) ? `0${this.runtime.endTime.getHours()}` : `${this.runtime.endTime.getHours()}`;
+        this.endTimeDay = (this.runtime.endTime.getDate() < 10) ? `0${this.runtime.endTime.getDate()}` : `${this.runtime.endTime.getDate()}`;
+        this.endTimeMonth = (this.runtime.endTime.getMonth() + 1 < 10) ? `0${this.runtime.endTime.getMonth() + 1}` : `${this.runtime.endTime.getMonth() + 1}`;
+    }
+}
+exports.CalculateRuntime = CalculateRuntime;

package/build/cjs/auxta/utilities/screenshot.helper.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function captureScreenshot(): Promise<Buffer | undefined>;

package/build/cjs/auxta/utilities/screenshot.helper.js

@@ -0,0 +1,36 @@
+"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 });
+exports.captureScreenshot = void 0;
+const puppeteer_1 = __importDefault(require("../../puppeteer/puppeteer"));
+function captureScreenshot() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const pages = yield puppeteer_1.default.defaultPage.browser().pages();
+            if (!pages.length)
+                return undefined;
+            const lastPage = pages[pages.length - 1] || puppeteer_1.default.defaultPage;
+            const screenshotBuffer = yield lastPage.screenshot({
+                fullPage: true,
+                encoding: 'binary'
+            });
+            if (Buffer.isBuffer(screenshotBuffer))
+                return screenshotBuffer;
+        }
+        catch (e) {
+        }
+        return undefined;
+    });
+}
+exports.captureScreenshot = captureScreenshot;

package/build/cjs/auxta/utilities/start-suite.helper.d.ts

@@ -0,0 +1 @@
+export declare function startSuite(suites: string[], reportId?: string): Promise<void>;

package/build/cjs/auxta/utilities/start-suite.helper.js

@@ -0,0 +1,32 @@
+"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 });
+exports.startSuite = void 0;
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../configs/config");
+function startSuite(suites, reportId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (suites.length === 0)
+            return;
+        const next = suites.shift();
+        console.log('Starting next suite: ' + next);
+        try {
+            yield axios_1.default.post(`${config_1.config.netlifyPath}.netlify/functions/${next}?token=${config_1.config.token}`, { nextSuites: suites, reportId: reportId });
+        }
+        catch (e) {
+            yield startSuite(suites, reportId);
+        }
+    });
+}
+exports.startSuite = startSuite;

package/build/cjs/macros/helpers/code.helper.d.ts

@@ -0,0 +1,22 @@
+import { StatusOfStep } from "../../auxta/enums/status-of.step";
+export declare class FunctionHelper {
+    readonly defaultTimeout: number;
+    log(keyword: string, name: string, status: StatusOfStep): void;
+    suggest(name: string): void;
+    private getEscapedText;
+    clickByText(selector: string, text: string, page?: import("puppeteer-core").Page, dotOrText?: string): Promise<void>;
+    clickByTextWithClass(class_selector: string, class_name: string, selector: string, text: string, page?: import("puppeteer-core").Page, dotOrText?: string): Promise<void>;
+    waitForSelectorWithText(selector: string, text: string, page?: import("puppeteer-core").Page, dotOrText?: string): Promise<boolean>;
+    goto(url: string, page?: import("puppeteer-core").Page): Promise<void>;
+    type(field: string, value: string, page?: import("puppeteer-core").Page): Promise<void>;
+    waitForNetwork(page?: import("puppeteer-core").Page): Promise<void>;
+    timeout(timeout?: number, page?: import("puppeteer-core").Page): Promise<void>;
+    waitForSelector(option: string, selector: string, time?: number, page?: import("puppeteer-core").Page, log_message?: boolean): Promise<void>;
+    click(selector: string, logMessages?: boolean, page?: import("puppeteer-core").Page): Promise<void>;
+    urlContains(selector: string, page?: import("puppeteer-core").Page): Promise<void>;
+    pressEnter(page?: import("puppeteer-core").Page): Promise<void>;
+    clickAndWaitForPageToBeCreated(selector: string, page?: import("puppeteer-core").Page): Promise<void>;
+    closeLastPage(page?: import("puppeteer-core").Page): Promise<void>;
+}
+declare const _default: FunctionHelper;
+export default _default;

package/build/cjs/macros/helpers/code.helper.js

@@ -0,0 +1,200 @@
+"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 });
+exports.FunctionHelper = void 0;
+const log_service_1 = __importDefault(require("../../auxta/services/log.service"));
+const puppeteer_1 = __importDefault(require("../../puppeteer/puppeteer"));
+const status_of_step_1 = require("../../auxta/enums/status-of.step");
+const config_1 = require("../../auxta/configs/config");
+class FunctionHelper {
+    constructor() {
+        this.defaultTimeout = config_1.config.timeout;
+    }
+    log(keyword, name, status) {
+        log_service_1.default.push(keyword, name, status);
+    }
+    suggest(name) {
+        log_service_1.default.addSuggestion(name);
+    }
+    getEscapedText(text) {
+        const splitedQuotes = text.replace(/'/g, `', "'", '`);
+        return `concat('${splitedQuotes}', '')`;
+    }
+    clickByText(selector, text, page = puppeteer_1.default.defaultPage, dotOrText = '.') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = `I click on the '${text}' '${selector}'`;
+            try {
+                const [linkHandlers] = yield page.$x(`//${selector}[${dotOrText} = ${this.getEscapedText(text)}]`);
+                if (linkHandlers) {
+                    yield linkHandlers.click();
+                    log_service_1.default.push('Then', message, status_of_step_1.StatusOfStep.PASSED);
+                    return;
+                }
+            }
+            catch (e) {
+            }
+            log_service_1.default.push('Then', message, status_of_step_1.StatusOfStep.FAILED);
+            throw new Error(message);
+        });
+    }
+    clickByTextWithClass(class_selector, class_name, selector, text, page = puppeteer_1.default.defaultPage, dotOrText = '.') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = `I click on the '${text}' '${selector}'`;
+            try {
+                const [linkHandlers] = yield page.$x(`//${class_selector}[contains(@class,${this.getEscapedText(class_name)})]//${selector}[${dotOrText} = ${this.getEscapedText(text)}]`);
+                if (linkHandlers) {
+                    yield linkHandlers.click();
+                    log_service_1.default.push('Then', message, status_of_step_1.StatusOfStep.PASSED);
+                    return;
+                }
+            }
+            catch (e) {
+            }
+            log_service_1.default.push('Then', message, status_of_step_1.StatusOfStep.FAILED);
+            throw new Error(message);
+        });
+    }
+    waitForSelectorWithText(selector, text, page = puppeteer_1.default.defaultPage, dotOrText = '.') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = `I check for '${text}' on the current page`;
+            try {
+                yield page.waitForSelector(selector, {
+                    timeout: this.defaultTimeout
+                });
+                const linkHandlers = yield page.$x(`//${selector}[${dotOrText} = ${this.getEscapedText(text)}]`);
+                if (linkHandlers.length > 0) {
+                    log_service_1.default.push('And', message, status_of_step_1.StatusOfStep.PASSED);
+                    return true;
+                }
+            }
+            catch (e) {
+            }
+            log_service_1.default.push('And', message, status_of_step_1.StatusOfStep.FAILED);
+            throw new Error(message);
+        });
+    }
+    goto(url, page = puppeteer_1.default.defaultPage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield page.goto(url);
+            log_service_1.default.push('Then', `I go to the '${url}' page`, status_of_step_1.StatusOfStep.PASSED);
+        });
+    }
+    type(field, value, page = puppeteer_1.default.defaultPage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield page.waitForSelector(field, {
+                    timeout: this.defaultTimeout
+                });
+                yield page.type(field, value);
+                let elementName = yield page.$eval(field, (e) => e.textContent);
+                if (!elementName || elementName === ' ')
+                    elementName = field;
+                log_service_1.default.push('Then', `I type '${value}' into the '${elementName}' field`, status_of_step_1.StatusOfStep.PASSED);
+            }
+            catch (e) {
+                const msg = `I type '${value}' into the '${field}' field`;
+                log_service_1.default.push('Then', msg, status_of_step_1.StatusOfStep.FAILED);
+                throw new Error(msg);
+            }
+        });
+    }
+    waitForNetwork(page = puppeteer_1.default.defaultPage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let message = 'I wait for the page to load';
+            try {
+                yield page.waitForNetworkIdle();
+                log_service_1.default.push('Then', message, status_of_step_1.StatusOfStep.PASSED);
+            }
+            catch (e) {
+                log_service_1.default.push('Then', message, status_of_step_1.StatusOfStep.FAILED);
+                throw new Error(message);
+            }
+        });
+    }
+    timeout(timeout = this.defaultTimeout, page = puppeteer_1.default.defaultPage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield page.waitForTimeout(timeout);
+        });
+    }
+    waitForSelector(option, selector, time = this.defaultTimeout, page = puppeteer_1.default.defaultPage, log_message = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = `I check for the '${selector}' element to be ${option}`;
+            try {
+                yield page.waitForSelector(selector, {
+                    [option]: true,
+                    timeout: time
+                });
+            }
+            catch (e) {
+                if (log_message) {
+                    log_service_1.default.push('And', message, status_of_step_1.StatusOfStep.FAILED);
+                }
+                throw new Error(message);
+            }
+            if (log_message) {
+                log_service_1.default.push('And', message, status_of_step_1.StatusOfStep.PASSED);
+            }
+        });
+    }
+    click(selector, logMessages = true, page = puppeteer_1.default.defaultPage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield page.waitForSelector(selector, {
+                    timeout: this.defaultTimeout
+                });
+                let elementName = yield page.$eval(selector, (e) => e.textContent);
+                if (!elementName || elementName === ' ')
+                    elementName = selector;
+                yield page.click(selector);
+                log_service_1.default.push('Then', `I click on the '${elementName}'`, status_of_step_1.StatusOfStep.PASSED);
+            }
+            catch (e) {
+                const msg = `I click on the '${selector}'`;
+                log_service_1.default.push('Then', msg, status_of_step_1.StatusOfStep.FAILED);
+                throw new Error(msg);
+            }
+        });
+    }
+    urlContains(selector, page = puppeteer_1.default.defaultPage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = page.url();
+            let message = `I am on the ${selector} page`;
+            if (!url.includes(selector)) {
+                log_service_1.default.push('And', message, status_of_step_1.StatusOfStep.FAILED);
+                throw new Error(message);
+            }
+            log_service_1.default.push('And', message, status_of_step_1.StatusOfStep.PASSED);
+        });
+    }
+    pressEnter(page = puppeteer_1.default.defaultPage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield page.keyboard.press('Enter');
+        });
+    }
+    clickAndWaitForPageToBeCreated(selector, page = puppeteer_1.default.defaultPage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nav = new Promise(res => page.browser().on('targetcreated', res));
+            yield this.click(selector);
+            yield nav;
+        });
+    }
+    closeLastPage(page = puppeteer_1.default.defaultPage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pages = yield page.browser().pages();
+            yield pages[pages.length - 1].close();
+        });
+    }
+}
+exports.FunctionHelper = FunctionHelper;
+exports.default = new FunctionHelper();

package/build/cjs/puppeteer/puppeteer.d.ts

@@ -0,0 +1,13 @@
+import { UploadModel } from "../auxta/models/upload.model";
+import puppeteer_core from 'puppeteer-core';
+export declare class Puppeteer {
+    defaultPage: puppeteer_core.Page;
+    private browser;
+    startBrowser(): Promise<void>;
+    close(): Promise<void>;
+    run(event: any, callback: any, featureName?: string, scenarioName?: string, uploadModel?: UploadModel, close?: boolean): Promise<void>;
+    runRPA(event: any, callback: any, close?: boolean): Promise<any>;
+    private static setupHeader;
+}
+declare const _default: Puppeteer;
+export default _default;