@applitools/eyes-testcafe 2.0.0-beta.9 → 3.0.0

package/dist/legacy.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformCheckSettings = exports.transformConfig = exports.LegacyTestCafeEyesMixin = void 0;
+const core_1 = require("@applitools/core");
+const eyes = require("@applitools/eyes");
+const utils = require("@applitools/utils");
+const fs = require("fs");
+const path = require("path");
+const spec = require("./spec-driver");
+function LegacyTestCafeEyesMixin(Eyes) {
+    return class TestCafeEyes extends Eyes {
+        constructor(runnerOrConfigOrOptions, configOrRunner) {
+            var _a, _b, _c;
+            if (utils.types.isNull(runnerOrConfigOrOptions) || utils.types.has(runnerOrConfigOrOptions, 'configPath')) {
+                const testcafeConfig = utils.config.getConfig({
+                    paths: (runnerOrConfigOrOptions === null || runnerOrConfigOrOptions === void 0 ? void 0 : runnerOrConfigOrOptions.configPath) ? [runnerOrConfigOrOptions.configPath] : undefined,
+                    params: ['failTestcafeOnDiff'],
+                });
+                const runner = (_a = runnerOrConfigOrOptions === null || runnerOrConfigOrOptions === void 0 ? void 0 : runnerOrConfigOrOptions.runner) !== null && _a !== void 0 ? _a : new eyes.VisualGridRunner({
+                    testConcurrency: (_c = (_b = testcafeConfig.concurrency) !== null && _b !== void 0 ? _b : testcafeConfig.testConcurrency) !== null && _c !== void 0 ? _c : 1,
+                });
+                super(runner, transformConfig(testcafeConfig));
+                this._testcafeConfig = testcafeConfig;
+            }
+            else {
+                super(runnerOrConfigOrOptions, configOrRunner);
+            }
+        }
+        async open(driverOrConfigOrAppNameOrOptions, configOrAppNameOrTestName, testNameOrViewportSize, viewportSizeOrSessionType, sessionType) {
+            var _a;
+            let driver, config;
+            if (spec.isDriver(driverOrConfigOrAppNameOrOptions)) {
+                driver = driverOrConfigOrAppNameOrOptions;
+                config = utils.types.isString(configOrAppNameOrTestName)
+                    ? {
+                        appName: configOrAppNameOrTestName,
+                        testName: testNameOrViewportSize,
+                        viewportSize: viewportSizeOrSessionType,
+                        sessionType,
+                    }
+                    : configOrAppNameOrTestName;
+            }
+            else if (utils.types.has(driverOrConfigOrAppNameOrOptions, 't')) {
+                const { t, ...testcafeConfig } = driverOrConfigOrAppNameOrOptions;
+                this._testcafeConfig = { ...this._testcafeConfig, ...testcafeConfig };
+                driver = t;
+                config = transformConfig(this._testcafeConfig);
+            }
+            else {
+                config = utils.types.isString(configOrAppNameOrTestName)
+                    ? {
+                        appName: configOrAppNameOrTestName,
+                        testName: testNameOrViewportSize,
+                        viewportSize: viewportSizeOrSessionType,
+                        sessionType,
+                    }
+                    : configOrAppNameOrTestName;
+            }
+            if ((_a = this._testcafeConfig) === null || _a === void 0 ? void 0 : _a.showLogs)
+                this.setLogHandler({ type: 'console' });
+            if (driver) {
+                // driver health check, re: https://trello.com/c/xNCZNfPi
+                await spec
+                    .executeScript(driver, () => true)
+                    .catch(() => {
+                    throw new Error(`The browser is in an invalid state due to JS errors on the page that TestCafe is unable to handle. Try running the test with TestCafe's --skip-js-errors option enabled: https://devexpress.github.io/testcafe/documentation/reference/configuration-file.html#skipjserrors`);
+                });
+                config;
+                return super.open(driver, config);
+            }
+            else {
+                return super.open(config);
+            }
+        }
+        async checkWindow(nameOrSetting, timeout, fully = true) {
+            if (utils.types.isObject(nameOrSetting)) {
+                return super.check(transformCheckSettings(nameOrSetting));
+            }
+            return super.checkWindow(nameOrSetting, timeout, fully);
+        }
+        async close(throwErr = true) {
+            var _a, _b;
+            return super.close(throwErr && ((_b = (_a = this._testcafeConfig) === null || _a === void 0 ? void 0 : _a.failTestcafeOnDiff) !== null && _b !== void 0 ? _b : true));
+        }
+        async waitForResults(throwErr = true) {
+            var _a, _b, _c;
+            const resultsSummary = await this.runner.getAllTestResults(throwErr && ((_b = (_a = this._testcafeConfig) === null || _a === void 0 ? void 0 : _a.failTestcafeOnDiff) !== null && _b !== void 0 ? _b : true));
+            if ((_c = this._testcafeConfig) === null || _c === void 0 ? void 0 : _c.tapDirPath) {
+                const results = resultsSummary.getAllResults().map(r => r.getTestResults());
+                const formatted = core_1.formatters.toHierarchicTAPString(results, {
+                    includeSubTests: false,
+                    markNewAsPassed: true,
+                });
+                fs.writeFileSync(path.resolve(this._testcafeConfig.tapDirPath, 'eyes.tap'), formatted);
+            }
+            return resultsSummary;
+        }
+    };
+}
+exports.LegacyTestCafeEyesMixin = LegacyTestCafeEyesMixin;
+function transformConfig(options) {
+    const config = { ...options };
+    if (options.concurrency)
+        config.concurrentSessions = options.concurrency;
+    if (options.envName) {
+        config.environmentName = options.envName;
+        delete config.envName;
+    }
+    if (options.browser) {
+        config.browsersInfo = utils.types.isArray(options.browser) ? options.browser : [options.browser];
+        delete config.browser;
+    }
+    if (options.batchId ||
+        options.batchName ||
+        options.notifyOnCompletion ||
+        process.env.APPLITOOLS_NOTIFY_ON_COMPLETION) {
+        config.batch = {
+            id: options.batchId,
+            name: options.batchName,
+            notifyOnCompletion: options.notifyOnCompletion || !!process.env.APPLITOOLS_NOTIFY_ON_COMPLETION,
+        };
+        delete config.batchId;
+        delete config.batchName;
+        delete config.notifyOnCompletion;
+    }
+    if (options.matchLevel || options.ignoreCaret || options.ignoreDisplacements || options.accessibilityValidation) {
+        config.defaultMatchSettings = {
+            ignoreCaret: options.ignoreCaret,
+            matchLevel: options.matchLevel,
+            ignoreDisplacements: options.ignoreDisplacements,
+            accessibilitySettings: options.accessibilityValidation,
+        };
+        delete config.ignoreCaret;
+        delete config.matchLevel;
+        delete config.ignoreDisplacements;
+        delete config.accessibilityValidation;
+    }
+    if (utils.types.isString(options.proxy)) {
+        config.proxy = { url: options.proxy };
+    }
+    return config;
+}
+exports.transformConfig = transformConfig;
+function transformCheckSettings(options) {
+    var _a;
+    const settings = { ...options };
+    settings.name = options.tag;
+    settings.hooks = options.scriptHooks;
+    settings.fully = (_a = options.fully) !== null && _a !== void 0 ? _a : options.target !== 'region';
+    if (options.target && options.target === 'region' && options.selector) {
+        settings.region = options.selector;
+    }
+    if (options.accessibility) {
+        const accessibilityRegions = utils.types.isArray(options.accessibility)
+            ? options.accessibility
+            : [options.accessibility];
+        settings.accessibilityRegions = accessibilityRegions.map(accessibilityRegion => {
+            const { accessibilityType, ...region } = accessibilityRegion;
+            if (utils.types.has(region, 'selector') && !utils.types.has(region, 'type')) {
+                return { region: region.selector, accessibilityType };
+            }
+            else {
+                return { region, accessibilityType };
+            }
+        });
+    }
+    if (options.floating) {
+        const floatingRegions = utils.types.isArray(options.floating) ? options.floating : [options.floating];
+        settings.floatingRegions = floatingRegions.map(floatingRegion => {
+            const { maxUpOffset, maxDownOffset, maxLeftOffset, maxRightOffset, ...region } = floatingRegion;
+            if (utils.types.has(region, 'selector') && !utils.types.has(region, 'type')) {
+                return { maxUpOffset, maxDownOffset, maxLeftOffset, maxRightOffset, region: region.selector };
+            }
+            else {
+                return { maxUpOffset, maxDownOffset, maxLeftOffset, maxRightOffset, region };
+            }
+        });
+    }
+    if (options.ignore) {
+        const ignoreRegions = utils.types.isArray(options.ignore) ? options.ignore : [options.ignore];
+        settings.ignoreRegions = ignoreRegions.map(region => {
+            if (utils.types.has(region, 'selector') && !utils.types.has(region, 'type')) {
+                return region.selector;
+            }
+            else {
+                return region;
+            }
+        });
+    }
+    if (options.layout) {
+        const layoutRegions = utils.types.isArray(options.layout) ? options.layout : [options.layout];
+        settings.layoutRegions = layoutRegions.map(region => {
+            if (utils.types.has(region, 'selector') && !utils.types.has(region, 'type')) {
+                return region.selector;
+            }
+            else {
+                return region;
+            }
+        });
+    }
+    if (options.strict) {
+        const strictRegions = utils.types.isArray(options.strict) ? options.strict : [options.strict];
+        settings.strictRegions = strictRegions.map(region => {
+            if (utils.types.has(region, 'selector') && !utils.types.has(region, 'type')) {
+                return region.selector;
+            }
+            else {
+                return region;
+            }
+        });
+    }
+    if (options.content) {
+        const contentRegions = utils.types.isArray(options.content) ? options.content : [options.content];
+        settings.contentRegions = contentRegions.map(region => {
+            if (utils.types.has(region, 'selector') && !utils.types.has(region, 'type')) {
+                return region.selector;
+            }
+            else {
+                return region;
+            }
+        });
+    }
+    return settings;
+}
+exports.transformCheckSettings = transformCheckSettings;

package/dist/spec-driver.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.takeScreenshot = exports.visit = exports.getUrl = exports.getTitle = exports.setViewportSize = exports.getDriverInfo = exports.childContext = exports.mainContext = exports.hover = exports.setElementText = exports.click = exports.findElements = exports.findElement = exports.executeScript = exports.extractSelector = exports.toSelector = exports.toElement = exports.isSelector = exports.isSecondaryElement = exports.isElement = exports.isDriver = void 0;
+const testcafe = require("testcafe");
+const fs = require("fs");
+const utils = require("@applitools/utils");
+function XPathSelector(selector, options) {
+    const getElementsByXPath = testcafe.Selector(xpath => {
+        /* eslint-disable no-undef */
+        const iterator = document.evaluate(xpath, document, null, XPathResult.UNORDERED_NODE_ITERATOR_TYPE, null);
+        /* eslint-enable */
+        const items = [];
+        let item = iterator.iterateNext();
+        while (item) {
+            items.push(item);
+            item = iterator.iterateNext();
+        }
+        return items;
+    }, options);
+    return testcafe.Selector(getElementsByXPath(selector), options);
+}
+function deserializeResult(result, elements) {
+    if (!result) {
+        return result;
+    }
+    else if (result.isElement) {
+        return elements.shift();
+    }
+    else if (utils.types.isArray(result)) {
+        return result.map(result => deserializeResult(result, elements));
+    }
+    else if (utils.types.isObject(result)) {
+        return Object.entries(result).reduce((object, [key, value]) => {
+            return Object.assign(object, { [key]: deserializeResult(value, elements) });
+        }, {});
+    }
+    else {
+        return result;
+    }
+}
+const scriptRunner = testcafe.ClientFunction(() => {
+    // @ts-ignore
+    const { script, arg } = input;
+    const func = new Function(script.startsWith('function') ? `return (${script}).apply(null, arguments)` : script);
+    const elements = [];
+    const result = serializeResult(func(deserializeArg(arg)));
+    const resultId = elements.length > 0 ? String(Math.floor(Math.random() * 1000)) : null;
+    if (resultId) {
+        const APPLITOOLS_NAMESPACE = '__TESTCAFE_EYES_APPLITOOLS__';
+        const global = window;
+        if (!global[APPLITOOLS_NAMESPACE])
+            global[APPLITOOLS_NAMESPACE] = {};
+        global[APPLITOOLS_NAMESPACE][resultId] = elements;
+    }
+    return { result, resultId, elementsCount: elements.length };
+    function deserializeArg(arg) {
+        if (!arg) {
+            return arg;
+        }
+        else if (typeof arg === 'function') {
+            return arg();
+        }
+        else if (Array.isArray(arg)) {
+            return arg.map(deserializeArg);
+        }
+        else if (typeof arg === 'object') {
+            return Object.entries(arg).reduce((object, [key, value]) => {
+                return Object.assign(object, { [key]: deserializeArg(value) });
+            }, {});
+        }
+        else {
+            return arg;
+        }
+    }
+    function serializeResult(result) {
+        if (!result) {
+            return result;
+        }
+        else if (result instanceof window.HTMLElement) {
+            elements.push(result);
+            return { isElement: true };
+        }
+        else if (Array.isArray(result)) {
+            return result.map(serializeResult);
+        }
+        else if (typeof result === 'object') {
+            return Object.entries(result).reduce((object, [key, value]) => {
+                return Object.assign(object, { [key]: serializeResult(value) });
+            }, {});
+        }
+        else {
+            return result;
+        }
+    }
+});
+const elementsExtractor = testcafe.Selector(() => {
+    // @ts-ignore
+    const { resultId } = input;
+    const APPLITOOLS_NAMESPACE = '__TESTCAFE_EYES_APPLITOOLS__';
+    const global = window;
+    if (!global[APPLITOOLS_NAMESPACE] || !global[APPLITOOLS_NAMESPACE][resultId])
+        return [];
+    const elements = global[APPLITOOLS_NAMESPACE][resultId];
+    return elements;
+});
+function isDriver(t) {
+    return utils.types.instanceOf(t, 'TestController');
+}
+exports.isDriver = isDriver;
+function isElement(element) {
+    if (!element)
+        return false;
+    return !!(element.addCustomMethods && element.find && element.parent);
+}
+exports.isElement = isElement;
+function isSecondaryElement(element) {
+    if (!element)
+        return false;
+    return !!(element.nodeType && isElement(element.selector));
+}
+exports.isSecondaryElement = isSecondaryElement;
+function isSelector(selector) {
+    if (!selector)
+        return false;
+    return Boolean(selector.addCustomMethods && selector.find && selector.parent);
+}
+exports.isSelector = isSelector;
+function toElement(element) {
+    if (utils.types.isFunction(element.selector))
+        return element.selector;
+    return element;
+}
+exports.toElement = toElement;
+function toSelector(selector) {
+    if (utils.types.has(selector, 'selector')) {
+        let current = selector;
+        let transformed = selector.type === 'xpath' ? XPathSelector(current.selector) : testcafe.Selector(current.selector);
+        while (current.child || current.shadow) {
+            if (current.child) {
+                current = utils.types.has(current.child, 'selector') ? current.child : { selector: current.child };
+                transformed = transformed.find(current.selector);
+            }
+            else if (current.shadow) {
+                current = utils.types.has(current.shadow, 'selector') ? current.shadow : { selector: current.shadow };
+                transformed = transformed.shadowRoot().find(current.selector);
+            }
+        }
+        return transformed;
+    }
+    return testcafe.Selector(selector);
+}
+exports.toSelector = toSelector;
+function extractSelector(element) {
+    return utils.types.isFunction(element.selector) ? element.selector : element;
+}
+exports.extractSelector = extractSelector;
+async function executeScript(t, script, arg) {
+    script = utils.types.isFunction(script) ? script.toString() : script;
+    const { result, resultId, elementsCount } = await scriptRunner.with({
+        boundTestRun: t,
+        dependencies: { input: { script, arg } },
+    })();
+    if (!result || !resultId)
+        return result;
+    const elements = elementsExtractor.with({
+        boundTestRun: t,
+        dependencies: { input: { resultId } },
+    });
+    return deserializeResult(result, Array.from({ length: elementsCount }, (_, index) => elements.nth(index)));
+}
+exports.executeScript = executeScript;
+async function findElement(t, selector) {
+    const element = await selector.with({ boundTestRun: t })();
+    return element ? element.selector : null;
+}
+exports.findElement = findElement;
+async function findElements(t, selector) {
+    const elements = selector.with({ boundTestRun: t });
+    return Array.from({ length: await elements.count }, (_, index) => elements.nth(index));
+}
+exports.findElements = findElements;
+async function click(t, element) {
+    await t.click(element);
+}
+exports.click = click;
+async function setElementText(t, element, text) {
+    await t.typeText(element, text);
+}
+exports.setElementText = setElementText;
+async function hover(t, element) {
+    await t.hover(element);
+}
+exports.hover = hover;
+async function mainContext(t) {
+    await t.switchToMainWindow();
+    return t;
+}
+exports.mainContext = mainContext;
+async function childContext(t, element) {
+    await t.switchToIframe(element);
+    return t;
+}
+exports.childContext = childContext;
+async function getDriverInfo(_t) {
+    return { features: { nestedSelectors: true } };
+}
+exports.getDriverInfo = getDriverInfo;
+async function setViewportSize(t, size) {
+    await t.resizeWindow(size.width, size.height);
+}
+exports.setViewportSize = setViewportSize;
+async function getTitle(t) {
+    try {
+        return await testcafe.Selector('title', { boundTestRun: t }).innerText;
+    }
+    catch (error) {
+        return '';
+    }
+}
+exports.getTitle = getTitle;
+async function getUrl(t) {
+    return testcafe.ClientFunction(() => document.location.href, { boundTestRun: t })();
+}
+exports.getUrl = getUrl;
+async function visit(t, url) {
+    await t.navigateTo(url);
+}
+exports.visit = visit;
+async function takeScreenshot(t) {
+    // NOTE:
+    // Since we are constrained to saving screenshots to disk, we place each screenshot in its own
+    // dot-folder which has a GUID prefix (e.g., .applitools-guide/screenshot.png).
+    // We then read the file from disk, return the buffer, and delete the folder.
+    const screenshotPath = await t.takeScreenshot({
+        // thumbnails: false,
+        path: `.applitools/${utils.general.guid()}.png`,
+    });
+    try {
+        return fs.readFileSync(screenshotPath);
+    }
+    finally {
+        fs.unlinkSync(screenshotPath);
+    }
+}
+exports.takeScreenshot = takeScreenshot;

package/package.json

@@ -1,45 +1,7 @@
 {
   "name": "@applitools/eyes-testcafe",
-  "private": false,
-  "version": "2.0.0-beta.9",
-  "description": "Applitools Eyes SDK for Testcafe",
-  "homepage": "https://applitools.com",
-  "author": {
-    "name": "Applitools Team",
-    "email": "team@applitools.com"
-  },
-  "files": [
-    "dist",
-    "lib",
-    "index.js"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/applitools/eyes.sdk.javascript1.git"
-  },
-  "bugs": {
-    "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
-  },
-  "directories": {
-    "lib": "./lib",
-    "dist": "./dist"
-  },
-  "main": "./index.js",
-  "dependencies": {
-    "@applitools/dom-utils": "^4.7.4",
-    "@applitools/eyes-common": "^3.18.0",
-    "@applitools/eyes-sdk-core": "^6.0.3",
-    "@applitools/functional-commons": "^1.5.4",
-    "@applitools/visual-grid-client": "^13.5.8",
-    "rimraf": "^3.0.0"
-  },
-  "peerDependencies": {
-    "testcafe": "^1.5.0"
-  },
-  "license": "SEE LICENSE FILE",
-  "engines": {
-    "node": ">=10.13.0"
-  },
+  "version": "3.0.0",
+  "description": "Applitools Eyes SDK for TestCafe",
   "keywords": [
     "eyes-testcafe",
     "eyes-rendering",
@@ -53,44 +15,78 @@
     "tests",
     "testcafe"
   ],
+  "homepage": "https://applitools.com",
+  "license": "SEE LICENSE IN LICENSE",
+  "author": {
+    "name": "Applitools Team",
+    "email": "team@applitools.com"
+  },
+  "main": "./dist/index-legacy.js",
+  "types": "./types/index-legacy.d.ts",
+  "typesVersions": {
+    "*": {
+      "dist": [
+        "./types/index.d.ts"
+      ],
+      "next": [
+        "./types/index.d.ts"
+      ]
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./types/index-legacy.d.ts",
+      "default": "./dist/index-legacy.js"
+    },
+    "./dist/*": {
+      "types": "./types/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./next": {
+      "types": "./types/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "types"
+  ],
   "scripts": {
-    "build": "rollup -c ./build/rollup.config.js",
-    "render": "node scripts/render.js",
-    "test": "mocha --no-timeouts \"test/**/*.spec2.js\"",
-    "test:unit": "mocha --no-timeouts \"test/unit/**/*.spec2.js\"",
-    "test:it": "mocha --no-timeouts \"test/it/**/*.spec2.js\"",
-    "test:e2e": "mocha --no-timeouts \"test/e2e/**/*.spec2.js\"",
-    "test:perf": "mocha --no-timeouts \"test/perf/**/*.spec.js\"",
-    "test:coverage": "node test/coverage/index.js",
-    "li": "cd ../../ && npm i && cd -"
+    "lint": "run --top-level eslint '**/*.ts' '**/*.js'",
+    "build": "run --top-level tspc --project ./tsconfig.build.json",
+    "generate:tests": "NODE_OPTIONS='--experimental-import-meta-resolve --experimental-loader=@applitools/generic/dist/code-loader.js' generic ./test/generic/config.mjs",
+    "test": "run test:unit && run test:it && run test:coverage",
+    "test:unit": "run --top-level mocha './test/unit/*.spec.ts'",
+    "test:it": "run test:it:chrome",
+    "test:it:chrome": "testcafe chrome:headless './test/it/*.spec.ts'",
+    "test:it:firefox": "testcafe firefox:headless './test/it/*.spec.ts'",
+    "test:coverage": "APPLITOOLS_BATCH_NAME='JS Coverage Tests: eyes-testcafe' APPLITOOLS_BATCH_ID=$(uuidgen) testcafe chrome:headless './test/generated-coverage/*.spec.js' --concurrency 10",
+    "perf": "testcafe chrome:headless test/perf/perf.spec.js",
+    "perf:full": "run perf && run perf -c 5",
+    "perf:lite": "testcafe chrome:headless test/perf/perf-lite.spec.js",
+    "perf:lite:full": "run perf:lite && run perf:lite -c 5",
+    "up:framework": "yarn add --dev --caret testcafe${APPLITOOLS_FRAMEWORK_VERSION:+@$APPLITOOLS_FRAMEWORK_VERSION}"
+  },
+  "dependencies": {
+    "@applitools/driver": "1.14.3",
+    "@applitools/eyes": "1.10.0",
+    "@applitools/utils": "1.6.1"
   },
   "devDependencies": {
-    "@applitools/dom-capture": "^7.1.2",
-    "@applitools/sdk-test-kit": "^1.0.17",
-    "@babel/plugin-transform-async-to-generator": "^7.7.4",
-    "@babel/plugin-transform-regenerator": "^7.7.5",
-    "@babel/plugin-transform-runtime": "^7.7.6",
-    "@babel/plugin-transform-spread": "^7.7.4",
-    "@babel/preset-env": "^7.7.6",
-    "@joseph184/rollup-plugin-node-builtins": "^2.1.4",
-    "assert-rejects": "^1.0.0",
-    "axios": "^0.19.0",
-    "chai": "^4.2.0",
-    "chromedriver": "^78.0.0",
-    "core-js": "^3.6.1",
-    "express": "^4.17.1",
-    "filenamify": "^4.1.0",
-    "mocha": "^6.2.2",
-    "rollup": "^1.27.9",
-    "rollup-plugin-babel": "^4.3.3",
-    "rollup-plugin-commonjs": "^10.1.0",
-    "rollup-plugin-node-globals": "^1.4.0",
-    "rollup-plugin-node-resolve": "^5.2.0",
-    "rollup-plugin-polyfill": "^3.0.0",
-    "testcafe": "^1.5.0",
-    "testcafe-browser-provider-browserstack": "^1.10.1",
-    "ua-parser-js": "^0.7.20",
-    "url-polyfill": "^1.1.7",
-    "whatwg-fetch": "^3.0.0"
+    "@applitools/api-extractor": "^1.2.22",
+    "@applitools/bongo": "^5.6.1",
+    "@applitools/generic": "^3.3.10",
+    "@applitools/test-server": "^1.2.2",
+    "@applitools/test-utils": "^1.5.17",
+    "testcafe": "1"
+  },
+  "peerDependencies": {
+    "testcafe": ">=1.7.1"
+  },
+  "engines": {
+    "node": ">=12.13.0"
+  },
+  "publishConfig": {
+    "access": "public"
   }
-}
+}

package/types/index-legacy.d.ts

@@ -0,0 +1,2 @@
+import { Eyes } from './index';
+export = Eyes;