@wdio/browserstack-service 8.27.2 → 8.28.0

package/build/Percy/Percy-Handler.d.ts

@@ -0,0 +1,32 @@
+import type { Capabilities } from '@wdio/types';
+import type { BeforeCommandArgs, AfterCommandArgs } from '@wdio/reporter';
+declare class _PercyHandler {
+    private _percyAutoCaptureMode;
+    private _browser;
+    private _capabilities;
+    private _isAppAutomate?;
+    private _framework?;
+    private _testMetadata;
+    private _sessionName?;
+    private _isPercyCleanupProcessingUnderway?;
+    private _percyScreenshotCounter;
+    private _percyDeferredScreenshots;
+    private _percyScreenshotInterval;
+    private _percyCaptureMap?;
+    constructor(_percyAutoCaptureMode: string | undefined, _browser: WebdriverIO.Browser | WebdriverIO.MultiRemoteBrowser, _capabilities: Capabilities.RemoteCapability, _isAppAutomate?: boolean | undefined, _framework?: string | undefined);
+    _setSessionName(name: string): void;
+    teardown(): Promise<void>;
+    percyAutoCapture(eventName: string | null, sessionName: string | null): Promise<void>;
+    before(): Promise<void>;
+    deferCapture(sessionName: string, eventName: string | null): void;
+    isDOMChangingCommand(args: BeforeCommandArgs): boolean;
+    cleanupDeferredScreenshots(): Promise<void>;
+    browserBeforeCommand(args: BeforeCommandArgs): Promise<void>;
+    browserAfterCommand(args: BeforeCommandArgs & AfterCommandArgs): Promise<void>;
+    afterTest(): Promise<void>;
+    afterScenario(): Promise<void>;
+}
+declare const PercyHandler: typeof _PercyHandler;
+type PercyHandler = _PercyHandler;
+export default PercyHandler;
+//# sourceMappingURL=Percy-Handler.d.ts.map

package/build/Percy/Percy-Handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Percy-Handler.d.ts","sourceRoot":"","sources":["../../src/Percy/Percy-Handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAazE,cAAM,aAAa;IAUX,OAAO,CAAC,qBAAqB;IAC7B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,cAAc,CAAC;IACvB,OAAO,CAAC,UAAU,CAAC;IAbvB,OAAO,CAAC,aAAa,CAA6B;IAClD,OAAO,CAAC,YAAY,CAAC,CAAQ;IAC7B,OAAO,CAAC,iCAAiC,CAAC,CAAiB;IAC3D,OAAO,CAAC,uBAAuB,CAAS;IACxC,OAAO,CAAC,yBAAyB,CAAU;IAC3C,OAAO,CAAC,wBAAwB,CAAY;IAC5C,OAAO,CAAC,gBAAgB,CAAC,CAAiB;gBAG9B,qBAAqB,EAAE,MAAM,GAAG,SAAS,EACzC,QAAQ,EAAE,WAAW,CAAC,OAAO,GAAG,WAAW,CAAC,kBAAkB,EAC9D,aAAa,EAAE,YAAY,CAAC,gBAAgB,EAC5C,cAAc,CAAC,qBAAS,EACxB,UAAU,CAAC,oBAAQ;IAO/B,eAAe,CAAC,IAAI,EAAE,MAAM;IAItB,QAAQ;IAUR,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAmBrE,MAAM;IAIZ,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAM1D,oBAAoB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO;IA+BhD,0BAA0B;IAS1B,oBAAoB,CAAE,IAAI,EAAE,iBAAiB;IAoB7C,mBAAmB,CAAE,IAAI,EAAE,iBAAiB,GAAG,gBAAgB;IA0B/D,SAAS;IAMT,aAAa;CAKtB;AAGD,QAAA,MAAM,YAAY,EAAE,OAAO,aAAoD,CAAA;AAC/E,KAAK,YAAY,GAAG,aAAa,CAAA;AAEjC,eAAe,YAAY,CAAA"}

package/build/Percy/Percy-Handler.js

@@ -0,0 +1,156 @@
+import { o11yClassErrorHandler, sleep } from '../util.js';
+import PercyCaptureMap from './PercyCaptureMap.js';
+import * as PercySDK from './PercySDK.js';
+import { PercyLogger } from './PercyLogger.js';
+import { PERCY_DOM_CHANGING_COMMANDS_ENDPOINTS, CAPTURE_MODES } from '../constants.js';
+class _PercyHandler {
+    _percyAutoCaptureMode;
+    _browser;
+    _capabilities;
+    _isAppAutomate;
+    _framework;
+    _testMetadata = {};
+    _sessionName;
+    _isPercyCleanupProcessingUnderway = false;
+    _percyScreenshotCounter = 0;
+    _percyDeferredScreenshots = [];
+    _percyScreenshotInterval = null;
+    _percyCaptureMap;
+    constructor(_percyAutoCaptureMode, _browser, _capabilities, _isAppAutomate, _framework) {
+        this._percyAutoCaptureMode = _percyAutoCaptureMode;
+        this._browser = _browser;
+        this._capabilities = _capabilities;
+        this._isAppAutomate = _isAppAutomate;
+        this._framework = _framework;
+        if (!_percyAutoCaptureMode || !CAPTURE_MODES.includes(_percyAutoCaptureMode)) {
+            this._percyAutoCaptureMode = 'auto';
+        }
+    }
+    _setSessionName(name) {
+        this._sessionName = name;
+    }
+    async teardown() {
+        await new Promise((resolve) => {
+            setInterval(() => {
+                if (this._percyScreenshotCounter === 0) {
+                    resolve();
+                }
+            }, 1000);
+        });
+    }
+    async percyAutoCapture(eventName, sessionName) {
+        try {
+            if (eventName) {
+                if (!sessionName) {
+                    /* Service doesn't wait for handling of browser commands so the below counter is used in teardown method to delay service exit */
+                    this._percyScreenshotCounter += 1;
+                }
+                this._percyCaptureMap?.increment(sessionName ? sessionName : this._sessionName, eventName);
+                await (this._isAppAutomate ? PercySDK.screenshotApp(this._percyCaptureMap?.getName(sessionName ? sessionName : this._sessionName, eventName)) : await PercySDK.screenshot(this._browser, this._percyCaptureMap?.getName(sessionName ? sessionName : this._sessionName, eventName)));
+                this._percyScreenshotCounter -= 1;
+            }
+        }
+        catch (err) {
+            this._percyScreenshotCounter -= 1;
+            this._percyCaptureMap?.decrement(sessionName ? sessionName : this._sessionName, eventName);
+            PercyLogger.error(`Error while trying to auto capture Percy screenshot ${err}`);
+        }
+    }
+    async before() {
+        this._percyCaptureMap = new PercyCaptureMap();
+    }
+    deferCapture(sessionName, eventName) {
+        /* Service doesn't wait for handling of browser commands so the below counter is used in teardown method to delay service exit */
+        this._percyScreenshotCounter += 1;
+        this._percyDeferredScreenshots.push({ sessionName, eventName });
+    }
+    isDOMChangingCommand(args) {
+        /*
+          Percy screenshots which are to be taken on events such as send keys, element click & screenshot are deferred until
+          another DOM changing command is seen such that any DOM processing post the previous command is completed
+        */
+        return (typeof args.method === 'string' && typeof args.endpoint === 'string' &&
+            ((args.method === 'POST' &&
+                (PERCY_DOM_CHANGING_COMMANDS_ENDPOINTS.includes(args.endpoint) ||
+                    (
+                    /* click / clear element */
+                    args.endpoint.includes('/session/:sessionId/element') &&
+                        (args.endpoint.includes('click') ||
+                            args.endpoint.includes('clear'))) ||
+                    /* execute script sync / async */
+                    (args.endpoint.includes('/session/:sessionId/execute') && args.body?.script) ||
+                    /* Touch action for Appium */
+                    (args.endpoint.includes('/session/:sessionId/touch')))) ||
+                (args.method === 'DELETE' && args.endpoint === '/session/:sessionId')));
+    }
+    async cleanupDeferredScreenshots() {
+        this._isPercyCleanupProcessingUnderway = true;
+        for (const entry of this._percyDeferredScreenshots) {
+            await this.percyAutoCapture(entry.eventName, entry.sessionName);
+        }
+        this._percyDeferredScreenshots = [];
+        this._isPercyCleanupProcessingUnderway = false;
+    }
+    async browserBeforeCommand(args) {
+        try {
+            if (!this.isDOMChangingCommand(args)) {
+                return;
+            }
+            do {
+                await sleep(1000);
+            } while (this._percyScreenshotInterval);
+            this._percyScreenshotInterval = setInterval(async () => {
+                if (!this._isPercyCleanupProcessingUnderway) {
+                    clearInterval(this._percyScreenshotInterval);
+                    await this.cleanupDeferredScreenshots();
+                    this._percyScreenshotInterval = null;
+                }
+            }, 1000);
+        }
+        catch (err) {
+            PercyLogger.error(`Error while trying to cleanup deferred screenshots ${err}`);
+        }
+    }
+    async browserAfterCommand(args) {
+        try {
+            if (!args.endpoint || !this._percyAutoCaptureMode) {
+                return;
+            }
+            let eventName = null;
+            const endpoint = args.endpoint;
+            if (endpoint.includes('click') && ['click', 'auto'].includes(this._percyAutoCaptureMode)) {
+                eventName = 'click';
+            }
+            else if (endpoint.includes('screenshot') && ['screenshot', 'auto'].includes(this._percyAutoCaptureMode)) {
+                eventName = 'screenshot';
+            }
+            else if (endpoint.includes('actions') && ['auto'].includes(this._percyAutoCaptureMode)) {
+                if (args.body && args.body.actions && Array.isArray(args.body.actions) && args.body.actions.length && args.body.actions[0].type === 'key') {
+                    eventName = 'keys';
+                }
+            }
+            else if (endpoint.includes('/session/:sessionId/element') && endpoint.includes('value') && ['auto'].includes(this._percyAutoCaptureMode)) {
+                eventName = 'keys';
+            }
+            if (eventName) {
+                this.deferCapture(this._sessionName, eventName);
+            }
+        }
+        catch (err) {
+            PercyLogger.error(`Error while trying to calculate auto capture parameters ${err}`);
+        }
+    }
+    async afterTest() {
+        if (this._percyAutoCaptureMode && this._percyAutoCaptureMode === 'testcase') {
+            await this.percyAutoCapture('testcase', null);
+        }
+    }
+    async afterScenario() {
+        if (this._percyAutoCaptureMode && this._percyAutoCaptureMode === 'testcase') {
+            await this.percyAutoCapture('testcase', null);
+        }
+    }
+}
+// https://github.com/microsoft/TypeScript/issues/6543
+const PercyHandler = o11yClassErrorHandler(_PercyHandler);
+export default PercyHandler;

package/build/Percy/Percy.d.ts

@@ -0,0 +1,15 @@
+import type { BrowserstackConfig, UserConfig } from '../types.js';
+import type { Options } from '@wdio/types';
+declare class Percy {
+    #private;
+    isProcessRunning: boolean;
+    constructor(options: BrowserstackConfig & Options.Testrunner, config: Options.Testrunner, bsConfig: UserConfig);
+    healthcheck(): Promise<boolean | undefined>;
+    start(): Promise<boolean>;
+    stop(): Promise<unknown>;
+    isRunning(): boolean;
+    fetchPercyToken(): Promise<any>;
+    createPercyConfig(): Promise<unknown>;
+}
+export default Percy;
+//# sourceMappingURL=Percy.d.ts.map

package/build/Percy/Percy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Percy.d.ts","sourceRoot":"","sources":["../../src/Percy/Percy.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAI1C,cAAM,KAAK;;IAWP,gBAAgB,UAAQ;gBAEZ,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,UAAU,EAAE,QAAQ,EAAE,UAAU;IAexG,WAAW;IAWX,KAAK;IA4CL,IAAI;IAWV,SAAS;IAIH,eAAe;IAsBf,iBAAiB;CA8B1B;AAED,eAAe,KAAK,CAAA"}

package/build/Percy/Percy.js

@@ -0,0 +1,123 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawn } from 'node:child_process';
+import { nodeRequest, getBrowserStackUser, getBrowserStackKey, sleep } from '../util.js';
+import { PercyLogger } from './PercyLogger.js';
+import PercyBinary from './PercyBinary.js';
+const logDir = 'logs';
+class Percy {
+    #logfile = path.join(logDir, 'percy.log');
+    #address = process.env.PERCY_SERVER_ADDRESS || 'http://127.0.0.1:5338';
+    #binaryPath = null;
+    #options;
+    #config;
+    #proc = null;
+    #isApp;
+    #projectName = undefined;
+    isProcessRunning = false;
+    constructor(options, config, bsConfig) {
+        this.#options = options;
+        this.#config = config;
+        this.#isApp = Boolean(options.app);
+        this.#projectName = bsConfig.projectName;
+    }
+    async #getBinaryPath() {
+        if (!this.#binaryPath) {
+            const pb = new PercyBinary();
+            this.#binaryPath = await pb.getBinaryPath(this.#config);
+        }
+        return this.#binaryPath;
+    }
+    async healthcheck() {
+        try {
+            const resp = await nodeRequest('GET', 'percy/healthcheck', null, this.#address);
+            if (resp) {
+                return true;
+            }
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    async start() {
+        const binaryPath = await this.#getBinaryPath();
+        const logStream = fs.createWriteStream(this.#logfile, { flags: 'a' });
+        const token = await this.fetchPercyToken();
+        const configPath = await this.createPercyConfig();
+        if (!token) {
+            return false;
+        }
+        const commandArgs = [`${this.#isApp ? 'app:exec' : 'exec'}:start`];
+        if (configPath) {
+            commandArgs.push('-c', configPath);
+        }
+        this.#proc = spawn(binaryPath, commandArgs, { env: { ...process.env, PERCY_TOKEN: token } });
+        this.#proc.stdout.pipe(logStream);
+        this.#proc.stderr.pipe(logStream);
+        this.isProcessRunning = true;
+        const that = this;
+        this.#proc.on('close', function () {
+            that.isProcessRunning = false;
+        });
+        do {
+            const healthcheck = await this.healthcheck();
+            if (healthcheck) {
+                PercyLogger.debug('Percy healthcheck successful');
+                return true;
+            }
+            await sleep(1000);
+        } while (this.isProcessRunning);
+        return false;
+    }
+    async stop() {
+        const binaryPath = await this.#getBinaryPath();
+        return new Promise((resolve) => {
+            const proc = spawn(binaryPath, ['exec:stop']);
+            proc.on('close', (code) => {
+                this.isProcessRunning = false;
+                resolve(code);
+            });
+        });
+    }
+    isRunning() {
+        return this.isProcessRunning;
+    }
+    async fetchPercyToken() {
+        const projectName = this.#projectName;
+        try {
+            const type = this.#isApp ? 'app' : 'automate';
+            const response = await nodeRequest('GET', `api/app_percy/get_project_token?name=${projectName}&type=${type}`, {
+                username: getBrowserStackUser(this.#config),
+                password: getBrowserStackKey(this.#config)
+            }, 'https://api.browserstack.com');
+            PercyLogger.debug('Percy fetch token success : ' + response.token);
+            return response.token;
+        }
+        catch (err) {
+            PercyLogger.error(`Percy unable to fetch project token: ${err}`);
+            return null;
+        }
+    }
+    async createPercyConfig() {
+        if (!this.#options.percyOptions) {
+            return null;
+        }
+        const configPath = path.join(os.tmpdir(), 'percy.json');
+        const percyOptions = this.#options.percyOptions;
+        if (!percyOptions.version) {
+            percyOptions.version = '2';
+        }
+        return new Promise((resolve) => {
+            fs.writeFile(configPath, JSON.stringify(percyOptions), (err) => {
+                if (err) {
+                    PercyLogger.error(`Error creating percy config: ${err}`);
+                    resolve(null);
+                }
+                PercyLogger.debug('Percy config created at ' + configPath);
+                resolve(configPath);
+            });
+        });
+    }
+}
+export default Percy;

package/build/Percy/PercyBinary.d.ts

@@ -0,0 +1,10 @@
+import type { Options } from '@wdio/types';
+declare class PercyBinary {
+    #private;
+    constructor();
+    getBinaryPath(conf: Options.Testrunner): Promise<string>;
+    validateBinary(binaryPath: string): Promise<unknown>;
+    download(conf: any, destParentDir: any): Promise<string>;
+}
+export default PercyBinary;
+//# sourceMappingURL=PercyBinary.d.ts.map

package/build/Percy/PercyBinary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PercyBinary.d.ts","sourceRoot":"","sources":["../../src/Percy/PercyBinary.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAE1C,cAAM,WAAW;;;IAmDP,aAAa,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAgBxD,cAAc,CAAC,UAAU,EAAE,MAAM;IAiBjC,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,aAAa,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;CAmEjE;AAED,eAAe,WAAW,CAAA"}

package/build/Percy/PercyBinary.js

@@ -0,0 +1,149 @@
+import url from 'node:url';
+import yauzl from 'yauzl';
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import got from 'got';
+import path from 'node:path';
+import os from 'node:os';
+import { spawn } from 'node:child_process';
+import { PercyLogger } from './PercyLogger.js';
+class PercyBinary {
+    #hostOS = process.platform;
+    #httpPath = null;
+    #binaryName = 'percy';
+    #orderedPaths = [
+        path.join(os.homedir(), '.browserstack'),
+        process.cwd(),
+        os.tmpdir()
+    ];
+    constructor() {
+        const base = 'https://github.com/percy/cli/releases/latest/download';
+        if (this.#hostOS.match(/darwin|mac os/i)) {
+            this.#httpPath = base + '/percy-osx.zip';
+        }
+        else if (this.#hostOS.match(/mswin|msys|mingw|cygwin|bccwin|wince|emc|win32/i)) {
+            this.#httpPath = base + '/percy-win.zip';
+            this.#binaryName = 'percy.exe';
+        }
+        else {
+            this.#httpPath = base + '/percy-linux.zip';
+        }
+    }
+    async #makePath(path) {
+        if (await this.#checkPath(path)) {
+            return true;
+        }
+        return fsp.mkdir(path).then(() => true).catch(() => false);
+    }
+    async #checkPath(path) {
+        try {
+            const hasDir = await fsp.access(path).then(() => true, () => false);
+            if (hasDir) {
+                return true;
+            }
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    async #getAvailableDirs() {
+        for (let i = 0; i < this.#orderedPaths.length; i++) {
+            const path = this.#orderedPaths[i];
+            if (await this.#makePath(path)) {
+                return path;
+            }
+        }
+        throw new Error('Error trying to download percy binary');
+    }
+    async getBinaryPath(conf) {
+        const destParentDir = await this.#getAvailableDirs();
+        const binaryPath = path.join(destParentDir, this.#binaryName);
+        if (await this.#checkPath(binaryPath)) {
+            return binaryPath;
+        }
+        const downloadedBinaryPath = await this.download(conf, destParentDir);
+        const isValid = await this.validateBinary(downloadedBinaryPath);
+        if (!isValid) {
+            // retry once
+            PercyLogger.error('Corrupt percy binary, retrying');
+            return await this.download(conf, destParentDir);
+        }
+        return downloadedBinaryPath;
+    }
+    async validateBinary(binaryPath) {
+        const versionRegex = /^.*@percy\/cli \d.\d+.\d+/;
+        /* eslint-disable @typescript-eslint/no-unused-vars */
+        return new Promise((resolve, reject) => {
+            const proc = spawn(binaryPath, ['--version']);
+            proc.stdout.on('data', (data) => {
+                if (versionRegex.test(data)) {
+                    resolve(true);
+                }
+            });
+            proc.on('close', () => {
+                resolve(false);
+            });
+        });
+    }
+    async download(conf, destParentDir) {
+        if (!await this.#checkPath(destParentDir)) {
+            await fsp.mkdir(destParentDir);
+        }
+        const binaryName = this.#binaryName;
+        const zipFilePath = path.join(destParentDir, binaryName + '.zip');
+        const binaryPath = path.join(destParentDir, binaryName);
+        const downloadedFileStream = fs.createWriteStream(zipFilePath);
+        const options = url.parse(this.#httpPath);
+        return new Promise((resolve, reject) => {
+            const stream = got.extend({ followRedirect: true }).get(this.#httpPath, { isStream: true });
+            stream.on('error', (err) => {
+                PercyLogger.error('Got Error in percy binary download response: ' + err);
+            });
+            stream.pipe(downloadedFileStream)
+                .on('finish', () => {
+                yauzl.open(zipFilePath, { lazyEntries: true }, function (err, zipfile) {
+                    if (err) {
+                        return reject(err);
+                    }
+                    zipfile.readEntry();
+                    zipfile.on('entry', (entry) => {
+                        if (/\/$/.test(entry.fileName)) {
+                            // Directory file names end with '/'.
+                            zipfile.readEntry();
+                        }
+                        else {
+                            // file entry
+                            const writeStream = fs.createWriteStream(path.join(destParentDir, entry.fileName));
+                            zipfile.openReadStream(entry, function (zipErr, readStream) {
+                                if (zipErr) {
+                                    reject(err);
+                                }
+                                readStream.on('end', function () {
+                                    writeStream.close();
+                                    zipfile.readEntry();
+                                });
+                                readStream.pipe(writeStream);
+                            });
+                            if (entry.fileName === binaryName) {
+                                zipfile.close();
+                            }
+                        }
+                    });
+                    zipfile.on('error', (zipErr) => {
+                        reject(zipErr);
+                    });
+                    zipfile.once('end', () => {
+                        fs.chmod(binaryPath, '0755', function (zipErr) {
+                            if (zipErr) {
+                                reject(zipErr);
+                            }
+                            resolve(binaryPath);
+                        });
+                        zipfile.close();
+                    });
+                });
+            });
+        });
+    }
+}
+export default PercyBinary;

package/build/Percy/PercyCaptureMap.d.ts

@@ -0,0 +1,9 @@
+declare class PercyCaptureMap {
+    #private;
+    increment(sessionName: string, eventName: string): void;
+    decrement(sessionName: string, eventName: string): void;
+    getName(sessionName: string, eventName: string): string;
+    get(sessionName: string, eventName: string): number;
+}
+export default PercyCaptureMap;
+//# sourceMappingURL=PercyCaptureMap.d.ts.map

package/build/Percy/PercyCaptureMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PercyCaptureMap.d.ts","sourceRoot":"","sources":["../../src/Percy/PercyCaptureMap.ts"],"names":[],"mappings":"AAKA,cAAM,eAAe;;IAGjB,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAYhD,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAQhD,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAI9C,GAAG,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;CAW7C;AAED,eAAe,eAAe,CAAA"}

package/build/Percy/PercyCaptureMap.js

@@ -0,0 +1,35 @@
+/*
+ * Maintains a counter for each driver to get consistent and
+ * unique screenshot names for percy
+ */
+class PercyCaptureMap {
+    #map = {};
+    increment(sessionName, eventName) {
+        if (!this.#map[sessionName]) {
+            this.#map[sessionName] = {};
+        }
+        if (!this.#map[sessionName][eventName]) {
+            this.#map[sessionName][eventName] = 0;
+        }
+        this.#map[sessionName][eventName]++;
+    }
+    decrement(sessionName, eventName) {
+        if (!this.#map[sessionName] || !this.#map[sessionName][eventName]) {
+            return;
+        }
+        this.#map[sessionName][eventName]--;
+    }
+    getName(sessionName, eventName) {
+        return `${sessionName}-${eventName}-${this.get(sessionName, eventName)}`;
+    }
+    get(sessionName, eventName) {
+        if (!this.#map[sessionName]) {
+            return 0;
+        }
+        if (!this.#map[sessionName][eventName]) {
+            return 0;
+        }
+        return this.#map[sessionName][eventName] - 1;
+    }
+}
+export default PercyCaptureMap;

package/build/Percy/PercyHelper.d.ts

@@ -0,0 +1,8 @@
+import type { Capabilities } from '@wdio/types';
+import type { BrowserstackConfig, UserConfig } from '../types.js';
+import type { Options } from '@wdio/types';
+import Percy from './Percy.js';
+export declare const startPercy: (options: BrowserstackConfig & Options.Testrunner, config: Options.Testrunner, bsConfig: UserConfig) => Promise<Percy>;
+export declare const stopPercy: (percy: Percy) => Promise<unknown>;
+export declare const getBestPlatformForPercySnapshot: (capabilities?: Capabilities.RemoteCapabilities) => any;
+//# sourceMappingURL=PercyHelper.d.ts.map

package/build/Percy/PercyHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PercyHelper.d.ts","sourceRoot":"","sources":["../../src/Percy/PercyHelper.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAEjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAG1C,OAAO,KAAK,MAAM,YAAY,CAAA;AAE9B,eAAO,MAAM,UAAU,YAAmB,kBAAkB,GAAG,QAAQ,UAAU,UAAU,QAAQ,UAAU,YAAY,UAAU,KAAG,QAAQ,KAAK,CAQlJ,CAAA;AAED,eAAO,MAAM,SAAS,UAAiB,KAAK,qBAG3C,CAAA;AAED,eAAO,MAAM,+BAA+B,kBAAmB,aAAa,kBAAkB,KAAI,GAgDjG,CAAA"}

package/build/Percy/PercyHelper.js

@@ -0,0 +1,67 @@
+// ======= Percy helper methods start =======
+import { PercyLogger } from './PercyLogger.js';
+import Percy from './Percy.js';
+export const startPercy = async (options, config, bsConfig) => {
+    PercyLogger.debug('Starting percy');
+    const percy = new Percy(options, config, bsConfig);
+    const response = await percy.start();
+    if (response) {
+        return percy;
+    }
+    return {};
+};
+export const stopPercy = async (percy) => {
+    PercyLogger.debug('Stopping percy');
+    return percy.stop();
+};
+export const getBestPlatformForPercySnapshot = (capabilities) => {
+    try {
+        const percyBrowserPreference = { 'chrome': 0, 'firefox': 1, 'edge': 2, 'safari': 3 };
+        let bestPlatformCaps = null;
+        let bestBrowser = null;
+        if (Array.isArray(capabilities)) {
+            capabilities
+                .flatMap((c) => {
+                if (Object.values(c).length > 0 && Object.values(c).every(c => typeof c === 'object' && c.capabilities)) {
+                    return Object.values(c).map((o) => o.capabilities);
+                }
+                return c;
+            }).forEach((capability) => {
+                let currBrowserName = capability.browserName;
+                if (capability['bstack:options']) {
+                    currBrowserName = capability['bstack:options'].browserName || currBrowserName;
+                }
+                if (!bestBrowser || !bestPlatformCaps || (bestPlatformCaps.deviceName || bestPlatformCaps['bstack:options']?.deviceName)) {
+                    bestBrowser = currBrowserName;
+                    bestPlatformCaps = capability;
+                }
+                else if (currBrowserName && percyBrowserPreference[currBrowserName.toLowerCase()] < percyBrowserPreference[bestBrowser.toLowerCase()]) {
+                    bestBrowser = currBrowserName;
+                    bestPlatformCaps = capability;
+                }
+            });
+            return bestPlatformCaps;
+        }
+        else if (typeof capabilities === 'object') {
+            Object.entries(capabilities).forEach(([, caps]) => {
+                let currBrowserName = caps.capabilities.browserName;
+                if (caps.capabilities['bstack:options']) {
+                    currBrowserName = caps.capabilities['bstack:options']?.browserName || currBrowserName;
+                }
+                if (!bestBrowser || !bestPlatformCaps || (bestPlatformCaps.deviceName || bestPlatformCaps['bstack:options']?.deviceName)) {
+                    bestBrowser = currBrowserName;
+                    bestPlatformCaps = caps.capabilities;
+                }
+                else if (currBrowserName && percyBrowserPreference[currBrowserName.toLowerCase()] < percyBrowserPreference[bestBrowser.toLowerCase()]) {
+                    bestBrowser = currBrowserName;
+                    bestPlatformCaps = caps.capabilities;
+                }
+            });
+            return bestPlatformCaps;
+        }
+    }
+    catch (err) {
+        PercyLogger.error(`Error while trying to determine best platform for Percy snapshot ${err}`);
+        return null;
+    }
+};

package/build/Percy/PercyLogger.d.ts

@@ -0,0 +1,15 @@
+export declare class PercyLogger {
+    static logFilePath: string;
+    private static logFolderPath;
+    private static logFileStream;
+    static logToFile(logMessage: string, logLevel: string): void;
+    private static formatLog;
+    static info(message: string): void;
+    static error(message: string): void;
+    static debug(message: string, param?: any): void;
+    static warn(message: string): void;
+    static trace(message: string): void;
+    static clearLogger(): void;
+    static clearLogFile(): void;
+}
+//# sourceMappingURL=PercyLogger.d.ts.map

package/build/Percy/PercyLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PercyLogger.d.ts","sourceRoot":"","sources":["../../src/Percy/PercyLogger.ts"],"names":[],"mappings":"AAWA,qBAAa,WAAW;IACpB,OAAc,WAAW,SAA4C;IACrE,OAAO,CAAC,MAAM,CAAC,aAAa,CAAmC;IAC/D,OAAO,CAAC,MAAM,CAAC,aAAa,CAAuB;IAEnD,MAAM,CAAC,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAgBrD,OAAO,CAAC,MAAM,CAAC,SAAS;WAIV,IAAI,CAAC,OAAO,EAAE,MAAM;WAKpB,KAAK,CAAC,OAAO,EAAE,MAAM;WAKrB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,GAAG;WASlC,IAAI,CAAC,OAAO,EAAE,MAAM;WAKpB,KAAK,CAAC,OAAO,EAAE,MAAM;WAKrB,WAAW;WAOX,YAAY;CAK7B"}