@applitools/eyes-cypress 3.28.2 → 3.29.0

package/dist/plugin/server.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webSocket_1 = __importDefault(require("./webSocket"));
+const eyes_universal_1 = require("@applitools/eyes-universal");
+const handleTestResults_1 = __importDefault(require("./handleTestResults"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const semver_1 = require("semver");
+const https_1 = require("https");
+const ws_1 = require("ws");
+const which_1 = __importDefault(require("which"));
+const util_1 = require("util");
+function makeStartServer({ logger }) {
+    return async function startServer() {
+        const key = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../src/pem/server.key'));
+        const cert = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../src/pem/server.cert'));
+        const https = new https_1.Server({
+            key,
+            cert,
+        });
+        await (0, util_1.promisify)(https.listen.bind(https))();
+        const port = https.address().port;
+        const wss = new ws_1.Server({ server: https, path: '/eyes', maxPayload: 254 * 1024 * 1024 });
+        wss.on('close', () => https.close());
+        const forkOptions = {
+            detached: true,
+        };
+        const cypressVersion = require('cypress/package.json').version;
+        if ((0, semver_1.lt)(cypressVersion, '7.0.0')) {
+            forkOptions.execPath = await (0, which_1.default)('node');
+        }
+        const { port: universalPort, close: closeUniversalServer } = await (0, eyes_universal_1.makeServerProcess)({
+            idleTimeout: 0,
+            shutdownMode: 'stdin',
+            forkOptions,
+            singleton: false,
+            portResolutionMode: 'random',
+        });
+        const managers = [];
+        let socketWithUniversal;
+        wss.on('connection', socketWithClient => {
+            socketWithUniversal = (0, webSocket_1.default)(`ws://localhost:${universalPort}/eyes`);
+            socketWithUniversal.setPassthroughListener((message) => {
+                logger.log('<== ', message.toString().slice(0, 1000));
+                const { name, payload } = JSON.parse(message);
+                if (name === 'Core.makeManager') {
+                    managers.push({ manager: payload.result, socketWithUniversal });
+                }
+                socketWithClient.send(message.toString());
+            });
+            socketWithClient.on('message', (message) => {
+                const msg = JSON.parse(message);
+                logger.log('==> ', message.toString().slice(0, 1000));
+                if (msg.name === 'Core.makeSDK') {
+                    const newMessage = Buffer.from(JSON.stringify({
+                        name: msg.name,
+                        key: msg.key,
+                        payload: Object.assign(msg.payload, { cwd: process.cwd() }),
+                    }), 'utf-8');
+                    socketWithUniversal.send(newMessage);
+                }
+                else if (msg.name === 'Test.printTestResults') {
+                    try {
+                        if (msg.payload.resultConfig.tapDirPath && msg.payload.resultConfig.shouldCreateTapFile) {
+                            handleTestResults_1.default.handleBatchResultsFile(msg.payload.testResults, {
+                                tapFileName: msg.payload.resultConfig.tapFileName,
+                                tapDirPath: msg.payload.resultConfig.tapDirPath,
+                            });
+                        }
+                        handleTestResults_1.default.printTestResults({
+                            testResults: msg.payload.testResults,
+                            resultConfig: msg.payload.resultConfig,
+                        });
+                        socketWithClient.send(JSON.stringify({
+                            name: 'Test.printTestResults',
+                            key: msg.key,
+                            payload: { result: 'success' },
+                        }));
+                    }
+                    catch (ex) {
+                        socketWithClient.send(JSON.stringify({
+                            name: 'Test.printTestResults',
+                            key: msg.key,
+                            payload: { result: ex.message.toString() },
+                        }));
+                    }
+                }
+                else {
+                    socketWithUniversal.send(message);
+                }
+            });
+        });
+        return {
+            server: wss,
+            port,
+            closeManager,
+            closeBatches,
+            closeUniversalServer,
+        };
+        function closeManager() {
+            return Promise.all(managers.map(({ manager, socketWithUniversal }) => socketWithUniversal.request('EyesManager.closeManager', {
+                manager,
+                throwErr: false,
+            })));
+        }
+        function closeBatches(settings) {
+            if (socketWithUniversal)
+                return socketWithUniversal.request('Core.closeBatches', { settings }).catch((err) => {
+                    logger.log('@@@', err);
+                });
+        }
+    };
+}
+exports.default = makeStartServer;

package/dist/plugin/webSocket.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ws_1 = __importDefault(require("ws"));
+const uuid_1 = require("uuid");
+function connectSocket(url) {
+    const socket = new ws_1.default(url);
+    let passthroughListener;
+    const listeners = new Map();
+    const queue = new Set();
+    let isReady = false;
+    attach();
+    function attach() {
+        if (socket.readyState === ws_1.default.CONNECTING)
+            socket.on('open', () => attach());
+        else if (socket.readyState === ws_1.default.OPEN) {
+            isReady = true;
+            queue.forEach((command) => command());
+            queue.clear();
+            socket.on('message', message => {
+                const { name, key, payload } = deserialize(message);
+                const fns = listeners.get(name);
+                const keyListeners = key && listeners.get(`${name}/${key}`);
+                if (fns)
+                    fns.forEach(fn => fn(payload, key));
+                if (keyListeners)
+                    keyListeners.forEach(fn => fn(payload, key));
+                if (!fns && !keyListeners && passthroughListener) {
+                    passthroughListener(message);
+                }
+            });
+        }
+    }
+    function disconnect() {
+        if (!socket)
+            return;
+        socket.terminate();
+        isReady = false;
+        passthroughListener = null;
+        queue.clear();
+    }
+    function setPassthroughListener(fn) {
+        passthroughListener = fn;
+    }
+    function send(message) {
+        const command = () => socket.send(message);
+        if (isReady)
+            command();
+        else
+            queue.add(command);
+        return () => queue.delete(command);
+    }
+    function on(type, fn) {
+        const name = typeof type === 'string' ? type : `${type.name}/${type.key}`;
+        let fns = listeners.get(name);
+        if (!fns) {
+            fns = new Set();
+            listeners.set(name, fns);
+        }
+        fns.add(fn);
+        return () => off(name, fn);
+    }
+    function once(type, fn) {
+        const off = on(type, (...args) => (fn(...args), off()));
+        return off;
+    }
+    function off(name, fn) {
+        if (!fn)
+            return listeners.delete(name);
+        const fns = listeners.get(name);
+        if (!fns)
+            return false;
+        const existed = fns.delete(fn);
+        if (!fns.size)
+            listeners.delete(name);
+        return existed;
+    }
+    function emit(type, payload) {
+        return send(serialize(type, payload));
+    }
+    function request(name, payload) {
+        return new Promise((resolve, reject) => {
+            const key = (0, uuid_1.v4)();
+            emit({ name, key }, payload);
+            once({ name, key }, (response) => {
+                if (response.error)
+                    return reject(response.error);
+                return resolve(response.result);
+            });
+        });
+    }
+    function ref() {
+        const command = () => socket._socket.ref();
+        if (isReady)
+            command();
+        else
+            queue.add(command);
+        return () => queue.delete(command);
+    }
+    function unref() {
+        const command = () => socket._socket.unref();
+        if (isReady)
+            command();
+        else
+            queue.add(command);
+        return () => queue.delete(command);
+    }
+    return {
+        setPassthroughListener,
+        send,
+        on,
+        once,
+        off,
+        request,
+        disconnect,
+        ref,
+        unref,
+    };
+}
+exports.default = connectSocket;
+function serialize(type, payload) {
+    const message = typeof type === 'string' ? { name: type, payload } : { name: type.name, key: type.key, payload };
+    return JSON.stringify(message);
+}
+function deserialize(message) {
+    return JSON.parse(message);
+}

package/index.js

@@ -1,2 +1,3 @@
-'use strict'
-module.exports = require('./src/plugin/startPlugin')
+const expose = require('./dist/expose')
+module.exports = expose.default
+Object.defineProperty(module.exports, 'default', {value: expose.default})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/eyes-cypress",
-  "version": "3.28.2",
+  "version": "3.29.0",
   "repository": {
     "type": "git",
     "url": "git://github.com/applitools/eyes.sdk.javascript1.git",
@@ -11,8 +11,8 @@
     "cypress",
     "cy"
   ],
-  "main": "index.js",
-  "types": "./index.d.ts",
+  "main": "./index.js",
+  "types": "./types/index.d.ts",
   "bin": {
     "eyes-setup": "./bin/eyes-setup.js"
   },
@@ -25,8 +25,8 @@
     "index.d.ts"
   ],
   "scripts": {
-    "lint": "eslint \"**/*.js\"",
-    "build": "tsc",
+    "lint": "eslint \"**/*.{js,ts}\"",
+    "build": "ttsc",
     "generate:tests": "coverage-tests generate",
     "test": "yarn test:unit && yarn test:it && yarn test:e2e && yarn test:ts && yarn test:components && yarn test:coverage",
     "test:sanity": "yarn test:unit && yarn test:it && yarn test:ts",
@@ -34,7 +34,16 @@
     "test:it": "yarn build && mocha --no-timeouts 'test/it/**/*.test.js'",
     "test:ts": "yarn test:ts:compile && yarn test:ts:run",
     "test:ts:compile": "tsc --project test/e2e/ts/cypress",
-    "test:ts:run": "cypress run --config-file test/e2e/ts/cypress-ts.json",
+    "test:ts:run:legacy": "yarn cypress9 run --config-file ./test/e2e/ts/cypress-ts-legacy.json",
+    "cypress9": "./node_modules/cypress9/bin/cypress",
+    "test:ts:run:9": "yarn cypress9 run --project ./test/e2e/ts --config-file ./cypress-9.config.ts",
+    "cypress10": "./node_modules/cypress10/bin/cypress",
+    "test:ts:run:10": "yarn cypress10 run --project ./test/e2e/ts --config-file ./cypress-10.config.ts",
+    "cypress11": "./node_modules/cypress11/bin/cypress",
+    "test:ts:run:11": "yarn cypress11 run --project ./test/e2e/ts --config-file ./cypress-11.config.ts",
+    "cypress12": "./node_modules/cypress12/bin/cypress",
+    "test:ts:run:12": "yarn cypress12 run --project ./test/e2e/ts --config-file ./cypress-12.config.ts",
+    "test:ts:run": "yarn test:ts:run:legacy && yarn test:ts:run:9",
     "test:coverage": "yarn generate:tests && cd test/coverage/generic && yarn && unset APPLITOOLS_API_KEY && APPLITOOLS_BATCH_NAME='JS Coverage Tests: eyes-cypress' APPLITOOLS_BATCH_ID=$(uuidgen) npx cypress run",
     "test:e2e": "mkdir -p test/fixtures/testAppCopies && mocha --no-timeouts 'test/e2e/**/*.test.js'",
     "test:components": "cd test/components && yarn && npx cypress run --component",
@@ -56,11 +65,13 @@
     }
   },
   "dependencies": {
-    "@applitools/core": "1.4.0",
-    "@applitools/eyes-api": "1.12.0",
+    "@applitools/core": "1.4.6",
+    "@applitools/eyes-api": "1.13.1",
     "@applitools/eyes-universal": "2.18.0",
     "@applitools/functional-commons": "1.6.0",
-    "@applitools/logger": "1.1.40",
+    "@applitools/logger": "1.1.43",
+    "@applitools/utils": "1.3.28",
+    "boxen": "5.1.2",
     "chalk": "3.0.0",
     "semver": "7.3.8",
     "uuid": "8.3.2",
@@ -68,26 +79,32 @@
     "ws": "8.5.0"
   },
   "devDependencies": {
+    "@applitools/api-extractor": "^1.2.11",
     "@applitools/bongo": "^2.2.2",
     "@applitools/scripts": "1.2.0",
-    "@applitools/sdk-coverage-tests": "^2.7.10",
+    "@applitools/sdk-coverage-tests": "^2.7.8",
     "@applitools/snaptdout": "1.0.1",
-    "@applitools/test-server": "1.1.20",
-    "@applitools/test-utils": "1.5.8",
-    "@applitools/utils": "1.3.26",
+    "@applitools/test-server": "1.1.22",
+    "@applitools/test-utils": "1.5.11",
     "@types/node": "12",
+    "@types/semver": "^7.3.13",
+    "@types/uuid": "^9.0.0",
     "@types/which": "^2.0.1",
     "@types/ws": "^8.2.2",
-    "@typescript-eslint/eslint-plugin": "^5.10.2",
-    "@typescript-eslint/parser": "^5.10.2",
+    "@typescript-eslint/eslint-plugin": "^5.47.1",
+    "@typescript-eslint/parser": "^5.47.1",
     "chai": "4.2.0",
     "chai-spies": "1.0.0",
     "cookie-parser": "1.4.4",
     "cypress": "9.7.0",
+    "cypress10": "npm:cypress@^10.0.0",
+    "cypress11": "npm:cypress@^11.0.0",
+    "cypress12": "npm:cypress@^12.0.0",
+    "cypress9": "npm:cypress@^9.0.0",
     "eslint": "8.10.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-mocha-no-only": "1.1.0",
-    "eslint-plugin-no-only-tests": "^3.0.0",
+    "eslint-plugin-no-only-tests": "^3.1.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-prettier": "^4.0.0",
     "husky": "4.3.8",
@@ -97,9 +114,11 @@
     "ncp": "2.0.0",
     "node-fetch": "2.6.0",
     "prettier": "^2.6.2",
-    "typescript": "4.8.4"
+    "ttypescript": "^1.5.13",
+    "typescript": "^4.7.2"
   },
   "engines": {
     "node": ">=12.13.0"
-  }
+  },
+  "xvfb": true
 }

package/src/browser/spec-driver.ts

@@ -37,7 +37,7 @@ export function childContext(_context: Context, element: HTMLIFrameElement): Con
   }
 }
 
-export function getViewportSize(): Object {
+export function getViewportSize(): {width: number; height: number} {
   //@ts-ignore
   const currWindow = cy.state('window')
   const viewportSize = {

package/src/expose.ts

@@ -0,0 +1,71 @@
+/*
+ * The types here are compiled via `ttsc` and `api-extractor`, and are used to describe the inputs to
+ * Eyes-Cypress custom commands. The reason they are not written in the `index.d.ts` file next to the
+ * `declare global { namespace Cypress {...}}` statement is that `api-extractor` has a limitation (at
+ * the time of writing this) that drops the `declare global` statement. So it's important to not pass
+ * `index.d.ts` through `api-extractor`,but keep the types in this file go through it, to produce the
+ * correct types for the SDK just like all other conventional SDK's.
+ **/
+/// <reference types="cypress" />
+import type * as api from '@applitools/eyes-api'
+import {type EyesSelector, type TestResultsStatus} from '@applitools/eyes-api'
+
+export type {EyesSelector, TestResultsStatus}
+
+type MaybeArray<T> = T | T[]
+
+type LegacyRegion = {left: number; top: number; width: number; height: number}
+type Selector = {selector: string; type?: 'css' | 'xpath'; nodeType?: 'element' | 'shadow-root'} | 'string'
+type Element = HTMLElement | JQuery<HTMLElement>
+type ElementWithOptions = {element: Element; regionId?: string; padding?: any}
+
+export type CypressCheckSettings = api.CheckSettingsAutomationPlain<Element, Selector> & {
+  tag?: CypressCheckSettings['name']
+
+  target?: 'window' | 'region'
+  selector?: Selector
+  element?: Element
+
+  ignore?: MaybeArray<NonNullable<CypressCheckSettings['ignoreRegions']>[number] | LegacyRegion | ElementWithOptions>
+  layout?: MaybeArray<NonNullable<CypressCheckSettings['layoutRegions']>[number] | LegacyRegion | ElementWithOptions>
+  content?: MaybeArray<NonNullable<CypressCheckSettings['contentRegions']>[number] | LegacyRegion | ElementWithOptions>
+  strict?: MaybeArray<NonNullable<CypressCheckSettings['strictRegions']>[number] | LegacyRegion | ElementWithOptions>
+  floating?: MaybeArray<
+    | NonNullable<CypressCheckSettings['floatingRegions']>[number]
+    | ((ElementWithOptions | Selector | LegacyRegion) & {
+        maxUpOffset?: number
+        maxDownOffset?: number
+        maxLeftOffset?: number
+        maxRightOffset?: number
+      })
+  >
+  accessibility?: MaybeArray<
+    | NonNullable<CypressCheckSettings['accessibilityRegions']>[number]
+    | ((ElementWithOptions | Selector | LegacyRegion) & {accessibilityType?: api.AccessibilityRegionTypePlain})
+  >
+  scriptHooks?: CypressCheckSettings['hooks']
+  ignoreCaret?: boolean
+  ignoreDisplacements?: boolean
+}
+export type CypressEyesConfig = api.ConfigurationPlain<Element, Selector> & {
+  browser?: MaybeArray<
+    | NonNullable<CypressEyesConfig['browsersInfo']>[number]
+    | {deviceName: string; screenOrientation?: api.ScreenOrientationPlain; name?: string}
+  >
+
+  batchId?: NonNullable<CypressEyesConfig['batch']>['id']
+  batchName?: NonNullable<CypressEyesConfig['batch']>['name']
+  batchSequence?: NonNullable<CypressEyesConfig['batch']>['sequenceName']
+  notifyOnCompletion?: NonNullable<CypressEyesConfig['batch']>['notifyOnCompletion']
+
+  envName?: CypressEyesConfig['environmentName']
+
+  accessibilitySettings?: NonNullable<CypressEyesConfig['defaultMatchSettings']>['accessibilitySettings']
+}
+
+export type CypressTestResultsSummary = api.TestResultsSummary
+
+export {type EyesPluginConfig} from './plugin'
+
+import plugin from './plugin'
+export default plugin

package/src/plugin/{concurrencyMsg.js → concurrencyMsg.ts}

@@ -5,4 +5,4 @@ Important notice: Your Applitools visual tests are currently running with a test
 This means that only up to 5 visual tests can run in parallel, and therefore the execution might be slower.
 If your Applitools license supports a higher concurrency level, learn how to configure it here: https://www.npmjs.com/package/@applitools/eyes-cypress#concurrency.
 Need a higher concurrency in your account? Email us @ sdr@applitools.com with your required concurrency level.`
-module.exports = {concurrencyMsg: chalk.yellow(MSG), msgText: MSG}
+export default {concurrencyMsg: chalk.yellow(MSG), msgText: MSG}

package/src/plugin/{config.js → config.ts}

@@ -1,19 +1,12 @@
-'use strict'
-const utils = require('@applitools/utils')
-const {configParams} = require('./configParams')
+import * as utils from '@applitools/utils'
+import configParams from './configParams'
 const DEFAULT_TEST_CONCURRENCY = 5
-const uuid = require('uuid')
+import * as uuid from 'uuid'
+import {type EyesPluginConfig} from './'
 
-function makeConfig() {
+export default function makeConfig(): {config: any; eyesConfig: EyesPluginConfig} {
   const config = utils.config.getConfig({
-    params: [
-      ...configParams,
-      'failCypressOnDiff',
-      'tapDirPath',
-      'tapFileName',
-      'disableBrowserFetching',
-      'testConcurrency',
-    ],
+    params: [...configParams, 'failCypressOnDiff', 'tapDirPath', 'tapFileName', 'disableBrowserFetching', 'testConcurrency'],
   })
 
   if ((!config.batch || !config.batch.id) && !config.batchId) {
@@ -51,5 +44,3 @@ function makeConfig() {
 
   return {config, eyesConfig}
 }
-
-module.exports = makeConfig

package/src/plugin/{configParams.js → configParams.ts}

@@ -1,5 +1,3 @@
-'use strict'
-
 const configParams = [
   'appName',
   'testName',
@@ -45,4 +43,4 @@ const configParams = [
   'dontCloseBatches',
 ]
 
-module.exports = {configParams}
+export default configParams

package/src/plugin/{errorDigest.js → errorDigest.ts}

@@ -1,5 +1,4 @@
-'use strict'
-
+type Color = 'reset' | 'green' | 'red' | 'teal' | 'orange'
 const colors = {
   green: '\x1b[32m',
   red: '\x1b[31m',
@@ -7,26 +6,48 @@ const colors = {
   orange: '\x1b[38;5;214m',
   reset: '\x1b[0m',
 }
-
-const formatByStatus = {
+const formatByStatus: Record<string, {color: Color; symbol: string; title: (tests: number) => string}> = {
   Passed: {
     color: 'green',
     symbol: '\u2713',
-    title: tests => `Passed - ${tests} tests`,
+    title: (tests: number) => `Passed - ${tests} tests`,
   },
   Failed: {
     color: 'red',
     symbol: '\u2716',
-    title: tests => `Errors - ${tests} tests`,
+    title: (tests: number) => `Errors - ${tests} tests`,
   },
   Unresolved: {
     color: 'orange',
     symbol: '\u26A0',
-    title: tests => `Diffs detected - ${tests} tests`,
+    title: (tests: number) => `Diffs detected - ${tests} tests`,
   },
 }
 
-function errorDigest({passed, failed, diffs, logger, isInteractive}) {
+function stringifyTestResults(testResults: any) {
+  const hostDisplaySize = testResults.hostDisplaySize
+  const viewport = hostDisplaySize ? `[${hostDisplaySize.width}x${hostDisplaySize.height}]` : ''
+  const testName = `${testResults.name} ${viewport}`
+  return testName + (testResults.error ? ` : ${testResults.error}` : '')
+}
+
+function testResultsSection(title: string, results: any) {
+  return results.length ? `${indent()}${title}${indent(3)}${results.join(indent(3))}` : ''
+}
+
+function stringifyError(testResults: any) {
+  return testResults.error ? stringifyTestResults(testResults) : `[Eyes test not started] : ${testResults}`
+}
+
+function indent(spaces = 2) {
+  return `\n   ${'  '.repeat(spaces)}`
+}
+
+function hasError(testResult: any) {
+  return testResult.error || testResult instanceof Error
+}
+
+export default function errorDigest({passed, failed, diffs, logger, isInteractive}: any) {
   logger.log('errorDigest: diff errors', diffs)
   logger.log('errorDigest: test errors', failed)
 
@@ -43,9 +64,9 @@ function errorDigest({passed, failed, diffs, logger, isInteractive}) {
     '\n\n'
   )
 
-  function testResultsToString(testResultsArr, category) {
-    const {color, title, symbol, chalkFunction} = formatByStatus[category]
-    const results = testResultsArr.reduce((acc, testResults) => {
+  function testResultsToString(testResultsArr: any, category: 'Passed' | 'Failed' | 'Unresolved') {
+    const {color, title, symbol} = formatByStatus[category]
+    const results = testResultsArr.reduce((acc: any, testResults: any) => {
       if (!testResults.isEmpty) {
         const error = hasError(testResults) ? stringifyError(testResults) : undefined
         acc.push(`${colorify(symbol, color)} ${colorify(error || stringifyTestResults(testResults))}`)
@@ -53,36 +74,11 @@ function errorDigest({passed, failed, diffs, logger, isInteractive}) {
       return acc
     }, [])
 
-    const coloredTitle = results.length ? colorify(title(results.length), color, chalkFunction) : ''
+    const coloredTitle = results.length ? colorify(title(results.length), color) : ''
     return testResultsSection(coloredTitle, results)
   }
 
-  function colorify(msg, color = 'reset') {
+  function colorify(msg: any, color: Color = 'reset') {
     return isInteractive ? msg : `${colors[color]}${msg}${colors.reset}`
   }
 }
-
-function stringifyTestResults(testResults) {
-  const hostDisplaySize = testResults.hostDisplaySize
-  const viewport = hostDisplaySize ? `[${hostDisplaySize.width}x${hostDisplaySize.height}]` : ''
-  const testName = `${testResults.name} ${viewport}`
-  return testName + (testResults.error ? ` : ${testResults.error}` : '')
-}
-
-function testResultsSection(title, results) {
-  return results.length ? `${indent()}${title}${indent(3)}${results.join(indent(3))}` : ''
-}
-
-function stringifyError(testResults) {
-  return testResults.error ? stringifyTestResults(testResults) : `[Eyes test not started] : ${testResults}`
-}
-
-function indent(spaces = 2) {
-  return `\n   ${'  '.repeat(spaces)}`
-}
-
-function hasError(testResult) {
-  return testResult.error || testResult instanceof Error
-}
-
-module.exports = errorDigest

package/src/plugin/{getErrorsAndDiffs.js → getErrorsAndDiffs.ts}

@@ -1,7 +1,6 @@
-'use strict'
-function getErrorsAndDiffs(testResultsArr) {
+export default function getErrorsAndDiffs(testResultsArr: any) {
   return testResultsArr.reduce(
-    ({failed, diffs, passed}, testResults) => {
+    ({failed, diffs, passed}: any, testResults: any) => {
       if (testResults instanceof Error || testResults.error) {
         failed.push(testResults)
       } else {
@@ -11,9 +10,7 @@ function getErrorsAndDiffs(testResultsArr) {
         } else {
           if (testStatus === 'Unresolved') {
             if (testResults.isNew) {
-              testResults.error = new Error(
-                `${testResults.name}. Please approve the new baseline at ${testResults.url}`,
-              )
+              testResults.error = new Error(`${testResults.name}. Please approve the new baseline at ${testResults.url}`)
               failed.push(testResults)
             } else {
               diffs.push(testResults)
@@ -29,5 +26,3 @@ function getErrorsAndDiffs(testResultsArr) {
     {failed: [], diffs: [], passed: []},
   )
 }
-
-module.exports = getErrorsAndDiffs