@applitools/core 4.59.2 → 4.59.4-debug.0

package/dist/universal/refer.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRefer = void 0;
+const utils = __importStar(require("@applitools/utils"));
+const REF_ID = 'applitools-ref-id';
+function makeRefer() {
+    const store = new Map();
+    const relation = new Map();
+    return { isRef, ref, deref, destroy };
+    function isRef(ref) {
+        return Boolean(ref[REF_ID]);
+    }
+    function ref(value, parentRef) {
+        const ref = utils.general.guid();
+        store.set(ref, value);
+        if (parentRef) {
+            let childRefs = relation.get(parentRef[REF_ID]);
+            if (!childRefs) {
+                childRefs = new Set();
+                relation.set(parentRef[REF_ID], childRefs);
+            }
+            childRefs.add({ [REF_ID]: ref });
+        }
+        return { [REF_ID]: ref };
+    }
+    function deref(ref) {
+        if (isRef(ref)) {
+            return store.get(ref[REF_ID]);
+        }
+        else {
+            return ref;
+        }
+    }
+    function destroy(ref) {
+        if (!isRef(ref))
+            return;
+        const childRefs = relation.get(ref[REF_ID]);
+        if (childRefs) {
+            childRefs.forEach(childRef => destroy(childRef));
+        }
+        store.delete(ref[REF_ID]);
+    }
+}
+exports.makeRefer = makeRefer;

package/dist/universal/spec-driver.js

@@ -0,0 +1,189 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSpec = void 0;
+const utils = __importStar(require("@applitools/utils"));
+function makeSpec({ socket, spec, }) {
+    const commands = {
+        isDriver(driver) {
+            return utils.types.has(driver, 'applitools-ref-id');
+        },
+        isContext(context) {
+            return utils.types.has(context, 'applitools-ref-id');
+        },
+        isElement(element) {
+            return utils.types.has(element, ['applitools-ref-id', 'type']) && element.type === 'element';
+        },
+        isSelector(selector) {
+            return ((utils.types.has(selector, ['applitools-ref-id', 'type']) && selector.type === 'selector') ||
+                utils.types.isString(selector) ||
+                (utils.types.isPlainObject(selector) &&
+                    utils.types.has(selector, 'selector') &&
+                    (utils.types.isString(selector.selector) || utils.types.has(selector, 'applitools-ref-id'))));
+        },
+        async isEqualElements(context, element1, element2) {
+            return socket.request('Driver.isEqualElements', { context, element1, element2 });
+        },
+        isStaleElementError(error) {
+            return error === null || error === void 0 ? void 0 : error.isStaleElementError;
+        },
+        extractContext(driver) {
+            return driver.context;
+        },
+        extractSelector(element) {
+            return element.selector;
+        },
+        async executeScript(context, script, arg) {
+            return socket.request('Driver.executeScript', { context, script: script.toString(), arg });
+        },
+        async findElement(context, selector, parent) {
+            return socket.request('Driver.findElement', { context, selector, parent });
+        },
+        async findElements(context, selector, parent) {
+            return socket.request('Driver.findElements', { context, selector, parent });
+        },
+        async waitForSelector(context, selector, parent, options) {
+            return socket.request('Driver.waitForSelector', { context, selector, parent, options });
+        },
+        async getElementText(context, element) {
+            return socket.request('Driver.getElementText', { context, element });
+        },
+        async setElementText(context, element, text) {
+            return socket.request('Driver.setElementText', { context, element, text });
+        },
+        async getElementRegion(context, element) {
+            return socket.request('Driver.getElementRegion', { context, element });
+        },
+        async getElementAttribute(context, element, attr) {
+            return socket.request('Driver.getElementAttribute', { context, element, attr });
+        },
+        async hover(context, element) {
+            return socket.request('Driver.hover', { context, element });
+        },
+        async click(context, element) {
+            return socket.request('Driver.click', { context, element });
+        },
+        async mainContext(context) {
+            return socket.request('Driver.mainContext', { context });
+        },
+        async parentContext(context) {
+            return socket.request('Driver.parentContext', { context });
+        },
+        async childContext(context, element) {
+            return socket.request('Driver.childContext', { context, element });
+        },
+        async getCapabilities(driver) {
+            return socket.request('Driver.getCapabilities', { driver });
+        },
+        async getDriverInfo(driver) {
+            return socket.request('Driver.getDriverInfo', { driver });
+        },
+        async getWindowSize(driver) {
+            return socket.request('Driver.getWindowSize', { driver });
+        },
+        async setWindowSize(driver, size) {
+            return socket.request('Driver.setWindowSize', { driver, size });
+        },
+        async getViewportSize(driver) {
+            return socket.request('Driver.getViewportSize', { driver });
+        },
+        async setViewportSize(driver, size) {
+            return socket.request('Driver.setViewportSize', { driver, size });
+        },
+        async getSystemBars(driver) {
+            return socket.request('Driver.getSystemBars', { driver });
+        },
+        async getOrientation(driver) {
+            return socket.request('Driver.getOrientation', { driver });
+        },
+        async setOrientation(driver, orientation) {
+            return socket.request('Driver.setOrientation', { driver, orientation });
+        },
+        async getCookies(driver, context) {
+            return socket.request('Driver.getCookies', { driver, context });
+        },
+        async getTitle(driver) {
+            return socket.request('Driver.getTitle', { driver });
+        },
+        async getUrl(driver) {
+            return socket.request('Driver.getUrl', { driver });
+        },
+        async takeScreenshot(driver) {
+            return socket.request('Driver.takeScreenshot', { driver });
+        },
+        async performAction(driver, steps) {
+            return socket.request('Driver.performAction', { driver, steps });
+        },
+        async visit(driver, url) {
+            return socket.request('Driver.visit', { driver, url });
+        },
+        async getCurrentWorld(driver) {
+            return socket.request('Driver.getCurrentWorld', { driver });
+        },
+        async getWorlds(driver) {
+            return socket.request('Driver.getWorlds', { driver });
+        },
+        async switchWorld(driver, name) {
+            return socket.request('Driver.switchWorld', { driver, name });
+        },
+        async reload(driver) {
+            return socket.request('Driver.reload', { driver });
+        },
+        async isUserFunction(ref) {
+            return utils.types.has(ref, 'applitools-ref-id');
+        },
+        async executeUserFunction(userFunction) {
+            return socket.request('Driver.executeUserFunction', userFunction);
+        },
+        async executeBrowserCommands(driver, commands) {
+            return socket.request('Driver.executeBrowserCommands', { driver, commands });
+        },
+        async bringToFront(driver) {
+            return socket.request('Driver.bringToFront', { driver });
+        },
+    };
+    // add default commands to spec (if not already there) such as `isUserFunction`
+    spec = addDefaultCommands(spec);
+    return spec.reduce((spec, name) => {
+        return Object.assign(spec, { [name]: commands[name] });
+    }, {});
+}
+exports.makeSpec = makeSpec;
+// returns a new clone of the spec commands array with additional commands universal can support even if the spec doesn't
+function addDefaultCommands(spec) {
+    const defaultCommands = [
+        {
+            command: 'isUserFunction',
+            dependsOn: ['executeUserFunction'],
+        },
+    ];
+    const commands = spec.slice();
+    defaultCommands.forEach(({ command, dependsOn }) => {
+        if (!commands.includes(command) && dependsOn.every(dep => commands.includes(dep))) {
+            commands.push(command);
+        }
+    });
+    return commands;
+}

package/dist/universal/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/universal/ws-server.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeServer = void 0;
+const http_1 = require("http");
+const https_1 = require("https");
+const ws_1 = require("ws");
+const { name, version } = require('../../package.json');
+const TOKEN_HEADER = 'x-eyes-universal-token';
+const TOKEN = `${name}@${version}`;
+async function makeServer(options = {}, logger) {
+    const { port = 21077, singleton = true, debug = false, portResolutionMode = 'next', cert, key } = options;
+    const secure = Boolean(cert && key);
+    const http = secure ? new https_1.Server({ cert, key }) : new http_1.Server();
+    http.on('request', (request, response) => {
+        if (request.url === '/handshake') {
+            const token = debug ? request.headers[TOKEN_HEADER] : TOKEN;
+            if (request.headers[TOKEN_HEADER] === token) {
+                response.writeHead(200, { [TOKEN_HEADER]: token });
+            }
+            else {
+                response.writeHead(400);
+            }
+            response.end();
+        }
+    });
+    const hostName = process.env.APPLITOOLS_UNIVERSAL_HOST_NAME || 'localhost';
+    http.listen(port, hostName);
+    return new Promise((resolve, reject) => {
+        http.on('listening', () => {
+            const ws = new ws_1.Server({ server: http, path: '/eyes', maxPayload: 256 * 1024 * 1024 });
+            ws.on('close', () => {
+                logger.log('Core universal server is closed');
+                http.close();
+            });
+            ws.on('error', err => {
+                logger.log('Core universal server error', err);
+            });
+            resolve({ server: ws, port: http.address().port });
+        });
+        http.on('error', async (err) => {
+            if (portResolutionMode !== 'lazy' && err.code === 'EADDRINUSE') {
+                if (singleton && (await isHandshakable({ port, secure }))) {
+                    return resolve({ port });
+                }
+                else {
+                    return resolve(await makeServer({ ...options, port: portResolutionMode === 'next' ? port + 1 : 0 }, logger));
+                }
+            }
+            reject(err);
+        });
+    });
+}
+exports.makeServer = makeServer;
+async function isHandshakable({ port, secure }) {
+    const request = secure ? https_1.request : http_1.request;
+    return new Promise(resolve => {
+        const handshake = request(`${secure ? 'https' : 'http'}://localhost:${port}/handshake`, {
+            headers: { [TOKEN_HEADER]: TOKEN },
+        });
+        handshake.on('response', ({ statusCode, headers }) => {
+            resolve(statusCode === 200 && headers[TOKEN_HEADER] === TOKEN);
+        });
+        handshake.on('error', () => resolve(false));
+        handshake.end();
+    });
+}

package/dist/utils/extract-git-info.js

@@ -39,14 +39,23 @@ exports.cacheKey = 'default';
  * Prefers 'origin' if it exists, otherwise uses the first available remote
  */
 exports.getPrimaryRemoteName = utils.general.cachify(async function ({ execOptions, logger = (0, logger_1.makeLogger)() }) {
+    const fnStart = Date.now();
+    if (isDebugMode())
+        logger.log(`[DEBUG] getPrimaryRemoteName: started`);
     const result = await executeWithLog('git remote show', { execOptions, logger });
     if (result.stderr) {
         logger.log(`Error during extracting remotes from git`, result.stderr);
+        if (isDebugMode())
+            logger.log(`[DEBUG] getPrimaryRemoteName: falling back to 'origin' after error in ${Date.now() - fnStart}ms`);
         return 'origin'; // Fallback to 'origin' if we can't determine remotes
     }
     const remotes = result.stdout.trim().split(/\s+/);
+    if (isDebugMode())
+        logger.log(`[DEBUG] getPrimaryRemoteName: parsed remotes: [${remotes.join(', ')}]`);
     const remote = remotes.includes('origin') ? 'origin' : remotes[0] || 'origin';
     logger.log(`Primary remote name: ${remote}`);
+    if (isDebugMode())
+        logger.log(`[DEBUG] getPrimaryRemoteName: completed in ${Date.now() - fnStart}ms`);
     return remote;
 }, args => {
     var _a;
@@ -55,9 +64,14 @@ exports.getPrimaryRemoteName = utils.general.cachify(async function ({ execOptio
     });
 });
 exports.extractLatestCommitInfo = utils.general.cachify(async function ({ execOptions, logger = (0, logger_1.makeLogger)(), }) {
+    const fnStart = Date.now();
+    if (isDebugMode())
+        logger.log(`[DEBUG] extractLatestCommitInfo: started`);
     let result;
     try {
         const githubPullRequestLastCommitSha = await extractGithubPullRequestLastCommitSha();
+        if (isDebugMode())
+            logger.log(`[DEBUG] extractLatestCommitInfo: githubPullRequestLastCommitSha = ${githubPullRequestLastCommitSha !== null && githubPullRequestLastCommitSha !== void 0 ? githubPullRequestLastCommitSha : '(none)'}`);
         result = await executeWithLog(`git log ${githubPullRequestLastCommitSha !== null && githubPullRequestLastCommitSha !== void 0 ? githubPullRequestLastCommitSha : ''} -1 --format="%aI %H"`, {
             execOptions,
             logger,
@@ -67,7 +81,11 @@ exports.extractLatestCommitInfo = utils.general.cachify(async function ({ execOp
         }
         else {
             const [timestamp, sha] = result.stdout.trim().split(' ');
+            if (isDebugMode())
+                logger.log(`[DEBUG] extractLatestCommitInfo: parsed timestamp=${timestamp}, sha=${sha}`);
             if (isISODate(timestamp)) {
+                if (isDebugMode())
+                    logger.log(`[DEBUG] extractLatestCommitInfo: completed in ${Date.now() - fnStart}ms`);
                 return { sha, timestamp };
             }
             else {
@@ -78,6 +96,8 @@ exports.extractLatestCommitInfo = utils.general.cachify(async function ({ execOp
     catch (err) {
         logger.log(`Error during parsing commit hash from git`, err, result === null || result === void 0 ? void 0 : result.stdout);
     }
+    if (isDebugMode())
+        logger.log(`[DEBUG] extractLatestCommitInfo: returning undefined after ${Date.now() - fnStart}ms`);
     async function extractGithubPullRequestLastCommitSha() {
         var _a, _b, _c;
         if (((_a = process.env.GITHUB_EVENT_NAME) === null || _a === void 0 ? void 0 : _a.startsWith('pull_request')) && process.env.GITHUB_EVENT_PATH) {
@@ -89,12 +109,19 @@ exports.extractLatestCommitInfo = utils.general.cachify(async function ({ execOp
     }
 }, () => exports.cacheKey);
 exports.extractGitBranch = utils.general.cachify(async function ({ execOptions, logger = (0, logger_1.makeLogger)() }) {
+    const fnStart = Date.now();
+    if (isDebugMode())
+        logger.log(`[DEBUG] extractGitBranch: started`);
     // 1. Try CI environment variables first (fast, no subprocess, handles detached HEAD in CI)
     const ciBranch = extractCIBranchName();
     if (ciBranch) {
         logger.log(`Extracted branch name from CI environment: "${ciBranch}"`);
+        if (isDebugMode())
+            logger.log(`[DEBUG] extractGitBranch: completed via CI env in ${Date.now() - fnStart}ms`);
         return ciBranch;
     }
+    if (isDebugMode())
+        logger.log(`[DEBUG] extractGitBranch: no CI branch env found, falling back to git command`);
     // 2. Fall back to git command (works when on an actual branch locally)
     const result = await executeWithLog('git branch --show-current', { execOptions, logger });
     if (result.stderr) {
@@ -102,26 +129,42 @@ exports.extractGitBranch = utils.general.cachify(async function ({ execOptions,
     }
     else {
         const branch = result.stdout.trim();
+        if (isDebugMode())
+            logger.log(`[DEBUG] extractGitBranch: git branch --show-current returned: "${branch}"`);
         if (branch) {
             logger.log(`Extracted current git branch: "${branch}"`);
+            if (isDebugMode())
+                logger.log(`[DEBUG] extractGitBranch: completed via git in ${Date.now() - fnStart}ms`);
             return branch;
         }
         logger.log('git branch --show-current returned empty (detached HEAD), no branch name available');
     }
+    if (isDebugMode())
+        logger.log(`[DEBUG] extractGitBranch: returning undefined after ${Date.now() - fnStart}ms`);
 }, args => { var _a, _b, _c; return ({ cwd: (_b = (_a = args[0]) === null || _a === void 0 ? void 0 : _a.execOptions) === null || _b === void 0 ? void 0 : _b.cwd, ignoreGitBranching: (_c = args[0]) === null || _c === void 0 ? void 0 : _c.ignoreGitBranching }); });
 exports.extractGitRepo = utils.general.cachify(async function ({ execOptions, logger = (0, logger_1.makeLogger)() }) {
+    const fnStart = Date.now();
+    if (isDebugMode())
+        logger.log(`[DEBUG] extractGitRepo: started`);
     const remotes = await extractRemotes();
     logger.log(`Extracted remotes from git: ${remotes}`);
     const remote = remotes.includes('origin') ? 'origin' : remotes[0];
+    if (isDebugMode())
+        logger.log(`[DEBUG] extractGitRepo: selected remote: "${remote}"`);
     const result = await executeWithLog(`git remote get-url ${remote}`, { execOptions, logger });
     if (result.stderr) {
         logger.log(`Error during extracting remote url from git`, result.stderr);
+        if (isDebugMode())
+            logger.log(`[DEBUG] extractGitRepo: returning {} after error in ${Date.now() - fnStart}ms`);
         return {};
     }
     else {
         const remoteUrl = result.stdout.trim();
         logger.log(`Extracted url for git remote ${remote}: ${remoteUrl}`);
-        return extractRepoFromRemoteUrl(remoteUrl);
+        const parsed = extractRepoFromRemoteUrl(remoteUrl);
+        if (isDebugMode())
+            logger.log(`[DEBUG] extractGitRepo: parsed repo: owner="${parsed.owner}", name="${parsed.name}" in ${Date.now() - fnStart}ms`);
+        return parsed;
     }
     async function extractRemotes() {
         const result = await executeWithLog('git remote show', { execOptions, logger });
@@ -162,7 +205,10 @@ async function extractBuildIdFromCI() {
 exports.extractBuildIdFromCI = extractBuildIdFromCI;
 exports.extractBranchingTimestamp = utils.general.cachify(async function ({ branchName, parentBranchName, execOptions, logger = (0, logger_1.makeLogger)(), }) {
     var _a;
+    const fnStart = Date.now();
     logger = logger.extend({ tags: [`extract-branching-timestamp-${utils.general.shortid()}`] });
+    if (isDebugMode())
+        logger.log(`[DEBUG] extractBranchingTimestamp: started (branch=${branchName}, parent=${parentBranchName})`);
     // Get the primary remote name (cached)
     const remoteName = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
     const shallowCheckResult = await executeWithLog('git rev-parse --is-shallow-repository', {
@@ -170,6 +216,8 @@ exports.extractBranchingTimestamp = utils.general.cachify(async function ({ bran
         logger,
     });
     const isShallow = shallowCheckResult.stdout.trim() === 'true';
+    if (isDebugMode())
+        logger.log(`[DEBUG] extractBranchingTimestamp: isShallow=${isShallow}`);
     if (isShallow) {
         logger.log('extractBranchingTimestamp - Repository is a shallow clone, attempting to unshallow');
         await executeFetchStrategy(isShallow, execOptions, logger);
@@ -177,10 +225,14 @@ exports.extractBranchingTimestamp = utils.general.cachify(async function ({ bran
     // Step 1: Try with remote refs first (fast path - uses already-fetched remote data)
     const command = `HASH=$(git merge-base ${branchName} ${parentBranchName}) && git show -q --format=%aI $HASH`;
     let result = await executeWithLog(command, { execOptions, logger });
+    if (isDebugMode())
+        logger.log(`[DEBUG] extractBranchingTimestamp: step 1 (local refs) stderr=${!!result.stderr}`);
     // Step 2: If remote refs failed, try local refs
     if (result.stderr) {
         const commandWithRemoteRefs = `HASH=$(git merge-base ${remoteName}/${branchName} ${remoteName}/${parentBranchName}) && git show -q --format=%aI $HASH`;
         result = await executeWithLog(commandWithRemoteRefs, { execOptions, logger });
+        if (isDebugMode())
+            logger.log(`[DEBUG] extractBranchingTimestamp: step 2 (remote refs) stderr=${!!result.stderr}`);
     }
     // Step 3: Handle missing branches with smart fetch (check remote existence first)
     // Fetch remote branches list once if there's an error (cached call - virtually free)
@@ -217,10 +269,14 @@ exports.extractBranchingTimestamp = utils.general.cachify(async function ({ bran
     const timestamp = result.stdout.replace(/\s/g, '');
     if (isISODate(timestamp)) {
         logger.log('git branching timestamp successfully extracted', timestamp);
+        if (isDebugMode())
+            logger.log(`[DEBUG] extractBranchingTimestamp: completed in ${Date.now() - fnStart}ms`);
         return timestamp;
     }
     else {
         logger.log(`Error during extracting merge timestamp: git branching timestamp is an invalid ISO date string: ${timestamp}. stderr: ${result.stderr}, stdout: ${result.stdout}`);
+        if (isDebugMode())
+            logger.log(`[DEBUG] extractBranchingTimestamp: returning undefined after ${Date.now() - fnStart}ms`);
     }
 }, args => {
     var _a;
@@ -234,8 +290,15 @@ async function executeWithLog(command, { execOptions, logger = (0, logger_1.make
     execOptions: {},
     logger: (0, logger_1.makeLogger)(),
 }) {
+    var _a;
     logger.log(`executing command: ${command}`);
+    const cmdStart = Date.now();
     const result = await utils.process.execute(command, execOptions);
+    if (isDebugMode()) {
+        const duration = Date.now() - cmdStart;
+        const preview = ((_a = result.stdout) === null || _a === void 0 ? void 0 : _a.trim().slice(0, 300)) || '(empty)';
+        logger.log(`[DEBUG] command took ${duration}ms | code: ${result.code} | stdout: ${preview}`);
+    }
     if (result.stderr && result.code) {
         logger.log(`exit code: ${result.code}, stderr: ${result.stderr}`);
     }
@@ -335,6 +398,9 @@ args => { var _a; return ({ cwd: (_a = args[0].execOptions) === null || _a === v
  * Determine fetch strategy and execute appropriate fetch operation
  */
 async function executeFetchStrategy(isShallow, execOptions, logger) {
+    const fnStart = Date.now();
+    if (isDebugMode())
+        logger.log(`[DEBUG] executeFetchStrategy: started (isShallow=${isShallow})`);
     const remoteName = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
     if (isShallow) {
         // Shallow clone needs full unshallow for initial topology discovery
@@ -354,6 +420,8 @@ async function executeFetchStrategy(isShallow, execOptions, logger) {
         });
         logger.log(`All remote branches fetched successfully`);
     }
+    if (isDebugMode())
+        logger.log(`[DEBUG] executeFetchStrategy: completed in ${Date.now() - fnStart}ms`);
 }
 /**
  * Helper function to check if we're dealing with a remote branch scenario
@@ -366,6 +434,9 @@ async function executeFetchStrategy(isShallow, execOptions, logger) {
  * @param logger - Logger instance
  */
 async function ensureRemoteBranchesAvailable(branchName, isShallow, execOptions, logger) {
+    const fnStart = Date.now();
+    if (isDebugMode())
+        logger.log(`[DEBUG] ensureRemoteBranchesAvailable: started (branch=${branchName}, isShallow=${isShallow})`);
     try {
         // Get the primary remote name (cached)
         const remoteName = await (0, exports.getPrimaryRemoteName)({ execOptions, logger });
@@ -374,8 +445,13 @@ async function ensureRemoteBranchesAvailable(branchName, isShallow, execOptions,
             execOptions,
             logger,
         });
-        const isRemoteBranch = symbolicResult.stdout.trim().startsWith(`${remoteName}/`);
+        const upstream = symbolicResult.stdout.trim();
+        const isRemoteBranch = upstream.startsWith(`${remoteName}/`);
+        if (isDebugMode())
+            logger.log(`[DEBUG] ensureRemoteBranchesAvailable: upstream="${upstream}", isRemoteBranch=${isRemoteBranch}`);
         if (!isRemoteBranch) {
+            if (isDebugMode())
+                logger.log(`[DEBUG] ensureRemoteBranchesAvailable: not a remote branch, skipping fetch in ${Date.now() - fnStart}ms`);
             return;
         }
         logger.log(`Detected remote branch scenario, fetching ancestor branches...`);
@@ -387,6 +463,8 @@ async function ensureRemoteBranchesAvailable(branchName, isShallow, execOptions,
         // Execute appropriate fetch strategy
         await executeFetchStrategy(isShallow, execOptions, logger);
         logger.log(`Remote branches fetched successfully for complete ancestor check`);
+        if (isDebugMode())
+            logger.log(`[DEBUG] ensureRemoteBranchesAvailable: completed in ${Date.now() - fnStart}ms`);
     }
     catch (err) {
         logger.log('Note: Could not determine if branch is remote, continuing with topology discovery', err);

package/dist/utils/populate-eyes-server-settings.js

@@ -37,6 +37,7 @@ function populateEyesServerSettings(settings) {
         apiKey: settings.apiKey,
         proxy: settings.proxy,
         useDnsCache: settings.useDnsCache,
+        httpVersion: settings.httpVersion,
     };
 }
 exports.populateEyesServerSettings = populateEyesServerSettings;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "4.59.2",
+  "version": "4.59.4-debug.0",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -60,19 +60,19 @@
     "setup:standalone": "sh -c 'yarn chromedriver --port=4444 --verbose &'"
   },
   "dependencies": {
-    "@applitools/core-base": "1.32.4",
-    "@applitools/dom-capture": "11.7.0",
-    "@applitools/dom-snapshot": "4.16.3",
-    "@applitools/driver": "1.25.4",
-    "@applitools/ec-client": "1.12.24",
-    "@applitools/logger": "2.2.10",
-    "@applitools/nml-client": "1.11.23",
-    "@applitools/req": "1.9.2",
-    "@applitools/screenshoter": "3.12.17",
-    "@applitools/snippets": "2.8.1",
-    "@applitools/socket": "1.3.11",
-    "@applitools/ufg-client": "1.20.2",
-    "@applitools/utils": "1.14.3",
+    "@applitools/core-base": "workspace:*",
+    "@applitools/dom-capture": "workspace:*",
+    "@applitools/dom-snapshot": "workspace:*",
+    "@applitools/driver": "workspace:*",
+    "@applitools/ec-client": "workspace:*",
+    "@applitools/logger": "workspace:*",
+    "@applitools/nml-client": "workspace:*",
+    "@applitools/req": "workspace:*",
+    "@applitools/screenshoter": "workspace:*",
+    "@applitools/snippets": "workspace:*",
+    "@applitools/socket": "workspace:*",
+    "@applitools/ufg-client": "workspace:*",
+    "@applitools/utils": "workspace:*",
     "abort-controller": "3.0.0",
     "chalk": "4.1.2",
     "node-fetch": "2.6.7",
@@ -80,12 +80,12 @@
     "throat": "6.0.2"
   },
   "devDependencies": {
-    "@applitools/bongo": "^5.10.0",
-    "@applitools/spec-driver-puppeteer": "^1.7.4",
-    "@applitools/spec-driver-selenium": "^1.7.15",
-    "@applitools/test-server": "^1.4.2",
-    "@applitools/test-utils": "^1.5.17",
-    "@applitools/tunnel-client": "^1.11.9",
+    "@applitools/bongo": "workspace:^",
+    "@applitools/spec-driver-puppeteer": "workspace:^",
+    "@applitools/spec-driver-selenium": "workspace:^",
+    "@applitools/test-server": "workspace:^",
+    "@applitools/test-utils": "workspace:^",
+    "@applitools/tunnel-client": "workspace:^",
     "@types/mocha": "^10.0.7",
     "@types/node": "^12.20.55",
     "@types/selenium-webdriver": "^4.1.2",
@@ -114,4 +114,4 @@
       "selenium-webdriver>ws>utf-8-validate": false
     }
   }
-}
+}

package/types/cli/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/types/ufg/utils/to-generated-selectors.d.ts

@@ -1,13 +1,14 @@
 import { type SpecType, type ElementReference } from '@applitools/driver';
 import type { Logger } from '@applitools/logger';
 import { type Selector as UFGSelector } from '@applitools/ufg-client';
-export declare function toGeneratedSelectors<TSpec extends SpecType>({ elementReferences, logger, }: {
+export declare function toGeneratedSelectors<TSpec extends SpecType>({ elementReferences, logger, logDeprecations, }: {
     elementReferences: {
         target?: ElementReference<TSpec>;
         scrolling?: ElementReference<TSpec>;
         calculate?: ElementReference<TSpec>[];
     };
     logger: Logger;
+    logDeprecations: (...args: string[]) => void;
 }): {
     elementReferencesToMark: (string | TSpec["element"] | TSpec["secondary"]["element"] | TSpec["selector"] | TSpec["secondary"]["selector"] | {
         selector: string | TSpec["selector"] | TSpec["secondary"]["selector"];