@applitools/core 4.37.0 → 4.38.0

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## [4.38.0](https://github.com/Applitools-Dev/sdk/compare/js/core@4.37.1...js/core@4.38.0) (2025-04-30)
+
+
+### Features
+
+* openCheckAndClose for offline executions ([#2941](https://github.com/Applitools-Dev/sdk/issues/2941)) ([d44a274](https://github.com/Applitools-Dev/sdk/commit/d44a27423520e17bfc06117b28c17e5f0ea78876))
+
+
+### Dependencies
+
+* @applitools/core-base bumped to 1.25.0
+  #### Features
+
+  * openCheckAndClose for offline executions ([#2941](https://github.com/Applitools-Dev/sdk/issues/2941)) ([d44a274](https://github.com/Applitools-Dev/sdk/commit/d44a27423520e17bfc06117b28c17e5f0ea78876))
+* @applitools/ec-client bumped to 1.10.11
+
+
+## [4.37.1](https://github.com/Applitools-Dev/sdk/compare/js/core@4.37.0...js/core@4.37.1) (2025-04-29)
+
+
+### Bug Fixes
+
+* handle slashes in branch name extraction from GITHUB_REF ([#2937](https://github.com/Applitools-Dev/sdk/issues/2937)) ([aa8bfa3](https://github.com/Applitools-Dev/sdk/commit/aa8bfa3118f43c52485362f729556acceea40ac6))
+
+
+### Dependencies
+
+* @applitools/driver bumped to 1.21.2
+  #### Bug Fixes
+
+  * not properly detected platform if written with underscore | FLD-2892  ([#2934](https://github.com/Applitools-Dev/sdk/issues/2934)) ([5ca4eb9](https://github.com/Applitools-Dev/sdk/commit/5ca4eb9d952cb089b7b3678d0d6f242ac7f9dad5))
+* @applitools/dom-snapshot bumped to 4.11.19
+
+* @applitools/spec-driver-webdriver bumped to 1.2.3
+
+* @applitools/spec-driver-selenium bumped to 1.5.99
+
+* @applitools/spec-driver-puppeteer bumped to 1.4.28
+
+* @applitools/screenshoter bumped to 3.11.2
+
+* @applitools/nml-client bumped to 1.9.2
+
+* @applitools/ec-client bumped to 1.10.10
+
+
 ## [4.37.0](https://github.com/Applitools-Dev/sdk/compare/js/core@4.36.0...js/core@4.37.0) (2025-04-17)
 
 

package/dist/offline/run-offline-snapshots.js

@@ -38,6 +38,7 @@ const utils = __importStar(require("@applitools/utils"));
 const merge_configs_1 = require("./merge-configs");
 const format_results_1 = require("../utils/format-results");
 const throat_1 = __importDefault(require("throat"));
+const throttledReadFile = (0, throat_1.default)(Number(process.env.APPLITOOLS_FILE_READING_CONCURRENCY) || 1000, fs_1.default.promises.readFile);
 function getConsoleLogLimit() {
     var _a;
     return (_a = utils.general.getEnvValue('OFFLINE_LOG_LIMIT', 'number')) !== null && _a !== void 0 ? _a : 20;
@@ -127,45 +128,97 @@ async function runOfflineSnapshots(options) {
         const environment = await ufgClient.getActualEnvironment({
             settings: { environment: openSettings.environment.requested },
         });
+        const closeSettings = await getCloseSettings(testPath);
+        let resultsGetter;
+        if (closeSettings) {
+            const targets = await getCheckTargets(testPath, logger);
+            const uploadResourcePromise = uploadResources(targets, logger).then(() => logger.log('uploaded resources for test', testPath));
+            if (targets.length === 1) {
+                logger.log('only one check found for test', testPath);
+                await uploadResourcePromise;
+                const target = targets[0];
+                resultsGetter = await runOpenCheckAndClose({
+                    ...target,
+                    settings: {
+                        ...(0, merge_configs_1.mergeConfigs)((0, merge_configs_1.mergeConfigs)(closeSettings, openSettings), target.settings),
+                        ...account.eyesServer,
+                        environment: {
+                            ...openSettings.environment,
+                            ...target.settings.environment,
+                        },
+                    },
+                }, logger, environment);
+                logger.log('finished running checks for test', testPath);
+            }
+            else {
+                const eyes = await openEyes(openSettings, environment, logger);
+                logger.log('opened eyes for test', testPath);
+                await uploadResourcePromise;
+                const lastTarget = targets.pop();
+                await Promise.all(targets.map((target, index) => runCheck(eyes, target, index, logger)));
+                if (lastTarget) {
+                    lastTarget.settings = (0, merge_configs_1.mergeConfigs)(lastTarget.settings, closeSettings);
+                    await runCheckAndClose(eyes, lastTarget, targets.length - 1, logger);
+                    logger.log('finished running checks for test', testPath);
+                }
+                else {
+                    logger.log('no checks found for test', testPath);
+                    // on empty test, `checkAndClose` will not be called so we need to call `close` instead
+                    await eyes.close({ settings: closeSettings });
+                }
+                resultsGetter = eyes;
+            }
+        }
+        else {
+            logger.log('no close settings found for test - aborting test', testPath);
+            resultsGetter = await makeAbortedTest(openSettings, environment, logger);
+        }
+        logger.log('done running test', testPath);
+        return { batchId: openSettings.batch.id, results: (await resultsGetter.getResults({ logger }))[0] };
+    }
+    async function getCloseSettings(testPath) {
+        const closeSettingsPath = path_1.default.resolve(testPath, 'close.json');
+        if (fs_1.default.existsSync(closeSettingsPath)) {
+            const fileCloseSettings = await throttledReadFile(closeSettingsPath, 'utf-8').then(JSON.parse);
+            const closeSettings = (0, merge_configs_1.mergeConfigs)(fileCloseSettings, options.config.close);
+            return closeSettings;
+        }
+        return undefined;
+    }
+    async function getCheckTargets(testPath, logger) {
+        const checkFolders = (await fs_1.default.promises.readdir(testPath)).filter(folderpath => folderpath.startsWith('check-'));
+        logger.log('check folders', checkFolders);
+        const targets = await Promise.all(checkFolders.map(async (checkFolder) => {
+            const snapshot = await fs_1.default.promises
+                .readFile(path_1.default.resolve(testPath, checkFolder, 'snapshot.json'), 'utf-8')
+                .then(JSON.parse);
+            snapshot.settings.environment.environmentId = utils.general.guid();
+            return snapshot;
+        }));
+        return targets;
+    }
+    async function makeAbortedTest(openSettings, environment, logger) {
+        const eyes = await openEyes(openSettings, environment, logger);
+        await eyes.abort({
+            settings: {
+                reason: 'internal',
+            },
+        });
+        return eyes;
+    }
+    async function openEyes(settings, environment, logger) {
         const eyes = await core.base.openEyes({
             settings: {
-                ...openSettings,
+                ...settings,
                 environment: {
-                    ...openSettings.environment,
+                    ...settings.environment,
                     ...environment,
                 },
                 ...account.eyesServer,
             },
             logger,
         });
-        const closeSettingsPath = path_1.default.resolve(testPath, 'close.json');
-        if (fs_1.default.existsSync(closeSettingsPath)) {
-            const checkFolders = (await fs_1.default.promises.readdir(testPath)).filter(folderpath => folderpath.startsWith('check-'));
-            logger.log('running checks for test', testPath, ':', checkFolders);
-            const targets = await Promise.all(checkFolders.map(async (checkFolder) => {
-                const snapshot = await fs_1.default.promises
-                    .readFile(path_1.default.resolve(testPath, checkFolder, 'snapshot.json'), 'utf-8')
-                    .then(JSON.parse);
-                snapshot.settings.environment.environmentId = utils.general.guid();
-                return snapshot;
-            }));
-            await uploadResources(targets, logger);
-            // logger.log('resource hashes for test', testFolder, ':', resourceHashes)
-            logger.log('uploaded resources for test', testPath);
-            await Promise.all(targets.map((target, index) => runCheck(eyes, target, index, logger)));
-            const fileCloseSettings = await fs_1.default.promises.readFile(closeSettingsPath, 'utf-8').then(JSON.parse);
-            const closeSettings = (0, merge_configs_1.mergeConfigs)(fileCloseSettings, options.config.close);
-            await eyes.close({ settings: closeSettings });
-        }
-        else {
-            await eyes.abort({
-                settings: {
-                    reason: 'internal',
-                },
-            });
-        }
-        logger.log('done running test', testPath);
-        return { batchId: openSettings.batch.id, results: (await eyes.getResults({ logger }))[0] };
+        return eyes;
     }
     async function uploadResources(targets, logger) {
         const uploadLogger = logger.extend({ tags: ['upload-resources'] });
@@ -176,7 +229,7 @@ async function runOfflineSnapshots(options) {
                 const contentfuleResource = {
                     id: '',
                     url: '',
-                    value: await fs_1.default.promises.readFile(path_1.default.join(offlineLocationPath, 'resources', resource.hash)),
+                    value: await throttledReadFile(path_1.default.join(offlineLocationPath, 'resources', resource.hash)),
                     contentType: resource.contentType,
                     hash: resource,
                 };
@@ -186,7 +239,7 @@ async function runOfflineSnapshots(options) {
                 resource: {
                     id: '',
                     url: '',
-                    value: await fs_1.default.promises.readFile(path_1.default.join(offlineLocationPath, 'resources', target.snapshot.hash)),
+                    value: await throttledReadFile(path_1.default.join(offlineLocationPath, 'resources', target.snapshot.hash)),
                     contentType: target.snapshot.contentType,
                     hash: target.snapshot,
                 },
@@ -202,6 +255,53 @@ async function runOfflineSnapshots(options) {
     async function runCheck(eyes, target, index, logger) {
         var _a;
         const checkLogger = logger.extend({ tags: [`check-${index}`] });
+        const { mergedCheckSettings, baseTarget } = await render(target, checkLogger);
+        (_a = mergedCheckSettings.stepIndex) !== null && _a !== void 0 ? _a : (mergedCheckSettings.stepIndex = index);
+        await eyes.check({
+            target: { ...baseTarget, isTransformed: true },
+            settings: mergedCheckSettings,
+            logger: checkLogger,
+        });
+        logger.log('check finished', mergedCheckSettings);
+        return eyes;
+    }
+    async function runCheckAndClose(eyes, target, index, logger) {
+        var _a;
+        const checkLogger = logger.extend({ tags: [`check-${index}`] });
+        const { mergedCheckSettings, baseTarget } = await render(target, checkLogger);
+        (_a = mergedCheckSettings.stepIndex) !== null && _a !== void 0 ? _a : (mergedCheckSettings.stepIndex = index);
+        await eyes.checkAndClose({
+            target: { ...baseTarget, isTransformed: true },
+            settings: mergedCheckSettings,
+            logger: checkLogger,
+        });
+        logger.log('checkAndClose finished', mergedCheckSettings);
+        return eyes;
+    }
+    async function runOpenCheckAndClose(target, logger, actualEnvironment) {
+        const checkLogger = logger.extend({ tags: ['open-check-and-close'] });
+        const { mergedCheckSettings, baseTarget } = await render(target, checkLogger);
+        const settings = (0, merge_configs_1.mergeConfigs)(target.settings, mergedCheckSettings);
+        return core.base.openCheckAndCloseEyes({
+            target: { ...baseTarget, isTransformed: true },
+            settings: {
+                ...settings,
+                environment: {
+                    ...settings.environment,
+                    ...actualEnvironment,
+                },
+            },
+            logger: checkLogger,
+            heartbeat: {
+                processId: '',
+                startPeriodicHeartbeatMessaging(settings) {
+                    logger.log('heartbeat is not used (offline)', settings);
+                },
+            },
+        });
+    }
+    async function render(target, logger) {
+        var _a;
         const { elementReferences: selectors, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({
             settings: target.settings,
         });
@@ -217,7 +317,7 @@ async function runOfflineSnapshots(options) {
                 uploadUrl: account.uploadUrl,
                 stitchingServiceUrl: account.stitchingServiceUrl,
             },
-            logger: checkLogger,
+            logger,
         });
         const baseSettings = getBaseCheckSettings({
             calculatedRegions: selectors.calculate.map((_, index) => {
@@ -228,15 +328,11 @@ async function runOfflineSnapshots(options) {
             }),
         });
         baseSettings.renderId = renderId;
-        baseSettings.stepIndex = index;
+        // baseSettings.stepIndex = index
         baseTarget.source = target.target.source; // TODO verify
         // baseTarget.name = snapshot.title // TODO figure out
         const mergedCheckSettings = (0, merge_configs_1.mergeConfigs)(baseSettings, options.config.check);
-        await eyes.check({
-            target: { ...baseTarget, isTransformed: true },
-            settings: mergedCheckSettings,
-            logger: checkLogger,
-        });
+        return { mergedCheckSettings, baseTarget };
     }
 }
 exports.runOfflineSnapshots = runOfflineSnapshots;

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

@@ -70,7 +70,7 @@ exports.extractGitBranch = utils.general.cachify(async function ({ execOptions,
         return process.env.GITHUB_HEAD_REF;
     }
     if (process.env.GITHUB_REF) {
-        return process.env.GITHUB_REF.split('/')[2]; // refs/heads/<branch_name>
+        return process.env.GITHUB_REF.split('/').splice(2).join('/'); // refs/heads/<branch_name>
     }
     const result = await executeWithLog('git branch --show-current', { execOptions, logger });
     if (result.stderr) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "4.37.0",
+  "version": "4.38.0",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -75,18 +75,18 @@
     }
   },
   "dependencies": {
-    "@applitools/core-base": "1.24.0",
+    "@applitools/core-base": "1.25.0",
     "@applitools/dom-capture": "11.5.5",
-    "@applitools/dom-snapshot": "4.11.18",
-    "@applitools/driver": "1.21.1",
-    "@applitools/ec-client": "1.10.9",
+    "@applitools/dom-snapshot": "4.11.19",
+    "@applitools/driver": "1.21.2",
+    "@applitools/ec-client": "1.10.11",
     "@applitools/logger": "2.1.2",
-    "@applitools/nml-client": "1.9.1",
+    "@applitools/nml-client": "1.9.2",
     "@applitools/req": "1.7.10",
-    "@applitools/screenshoter": "3.11.1",
+    "@applitools/screenshoter": "3.11.2",
     "@applitools/snippets": "2.6.5",
     "@applitools/socket": "1.2.3",
-    "@applitools/spec-driver-webdriver": "1.2.2",
+    "@applitools/spec-driver-webdriver": "1.2.3",
     "@applitools/ufg-client": "1.16.9",
     "@applitools/utils": "1.8.0",
     "@types/ws": "8.5.5",
@@ -102,8 +102,8 @@
   "devDependencies": {
     "@applitools/bongo": "^5.10.0",
     "@applitools/sea": "^1.0.0",
-    "@applitools/spec-driver-puppeteer": "^1.4.27",
-    "@applitools/spec-driver-selenium": "^1.5.98",
+    "@applitools/spec-driver-puppeteer": "^1.4.28",
+    "@applitools/spec-driver-selenium": "^1.5.99",
     "@applitools/test-server": "^1.2.2",
     "@applitools/test-utils": "^1.5.17",
     "@applitools/tunnel-client": "^1.6.5",

package/types/offline/merge-configs.d.ts

@@ -1 +1 @@
-export declare function mergeConfigs<TBase extends Record<string, any>>(base: TBase, other: Record<string, any>): TBase;
+export declare function mergeConfigs<TBase extends Record<string, any>, TBase2 extends Record<string, any>>(base: TBase, other: TBase2): TBase & TBase2;