@applitools/core 4.37.0-debug-20250429 → 4.37.0-debug-20250429-3

package/dist/automation/utils/to-base-check-settings.js

@@ -38,7 +38,7 @@ async function extractMobileElementsIntoCheckSettings({ settings, driver, logger
     logger = logger.extend({ tags: [`extract-mobile-elements-${utils.general.shortid()}`] });
     const environment = await driver.getEnvironment();
     if (settings.region) {
-        logger.log('extract element form region', settings.region);
+        logger.log('extract element from region', settings.region);
         const region = await driver.element(settings.region).catch(error => logger.log(error));
         if (!region) {
             throw new Error('region not found');
@@ -63,7 +63,7 @@ async function extractMobileElementsIntoCheckSettings({ settings, driver, logger
         if (!settings[`${regionType}Regions`])
             return obj;
         obj[`${regionType}Regions`] = (await Promise.all((_b = (_a = settings[`${regionType}Regions`]) === null || _a === void 0 ? void 0 : _a.flatMap(async (reference) => {
-            logger.log('extract element form region', reference);
+            logger.log('extract element from region', reference);
             const { region } = utils.types.has(reference, 'region') ? reference : { region: reference };
             const handleRegion = new Set();
             const elements = await driver.elements(region).catch(error => logger.log(error));

package/dist/classic/check.js

@@ -355,7 +355,7 @@ async function takeNMLScreenshot({ driver, settings, environments, logger, eyes,
                 aggregateCalculatedRegions.push({ regions, selector: reference });
             }
             else {
-                logger.log(`Regions "${reference}" was not found in the screenshot`);
+                logger.log(`Regions "${JSON.stringify(reference)}" was not found in the screenshot`);
             }
         });
         if ((_a = baseTarget.dom) === null || _a === void 0 ? void 0 : _a.error) {

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

@@ -127,45 +127,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 fs_1.default.promises.readFile(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'] });
@@ -202,6 +254,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 +316,7 @@ async function runOfflineSnapshots(options) {
                 uploadUrl: account.uploadUrl,
                 stitchingServiceUrl: account.stitchingServiceUrl,
             },
-            logger: checkLogger,
+            logger,
         });
         const baseSettings = getBaseCheckSettings({
             calculatedRegions: selectors.calculate.map((_, index) => {
@@ -228,15 +327,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/ufg/check.js

@@ -174,6 +174,12 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
                             },
                         });
                     }
+                    try {
+                        logInvalidSettings(logger, settings);
+                    }
+                    catch (err) {
+                        logger.log('Failed to log invalid check settings', err);
+                    }
                     await baseEyes.check({
                         target: { ...baseTarget, isTransformed: true },
                         settings: baseSettings,
@@ -204,3 +210,14 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
     };
 }
 exports.makeCheck = makeCheck;
+function logInvalidSettings(logger, settings) {
+    const invalidKeys = ['overlap', 'scrollRootElement', 'stitchMode'];
+    if (!settings)
+        return;
+    const invalidEntries = Object.entries(settings)
+        .filter(([key]) => invalidKeys.includes(key))
+        .filter(([_, value]) => value !== undefined);
+    if (invalidEntries.length > 0) {
+        logger.warn('Warning - Invalid keys in check settings (will be ignored):', { settings, invalidEntries });
+    }
+}

package/dist/ufg/utils/take-dom-snapshots.js

@@ -54,36 +54,50 @@ async function takeDomSnapshots({ driver, settings, hooks, provides, logger, })
         return Array(settings.environments.length).fill(snapshot);
     }
     const isStrictBreakpoints = utils.types.isArray((_b = settings.layoutBreakpoints) === null || _b === void 0 ? void 0 : _b.breakpoints);
-    const requiredWidths = await settings.environments.reduce(async (prev, environment, index) => {
-        const { name, width } = (await extractEnvironmentInfo(environment));
-        const requiredWidths = await prev;
-        const requiredWidth = isStrictBreakpoints
-            ? calculateBreakpoint({ breakpoints: settings.layoutBreakpoints.breakpoints, value: width })
-            : width;
-        let environments = requiredWidths.get(requiredWidth);
+    const initialViewportSize = await driver.getViewportSize();
+    const requiredSizes = await settings.environments.reduce(async (prev, environment, index) => {
+        var _a;
+        const { name, width, height } = (await extractEnvironmentInfo(environment));
+        const requiredSizes = await prev;
+        let requiredSize;
+        if ((_a = settings.layoutBreakpoints) === null || _a === void 0 ? void 0 : _a.heightBreakpoints) {
+            const requiredWidth = settings.layoutBreakpoints.breakpoints ? width : initialViewportSize.width;
+            requiredSize = `${requiredWidth},${height}`;
+        }
+        else {
+            const requiredWidth = isStrictBreakpoints
+                ? calculateBreakpoint({ breakpoints: settings.layoutBreakpoints.breakpoints, value: width })
+                : width;
+            requiredSize = `${requiredWidth},${initialViewportSize.height}`;
+        }
+        let environments = requiredSizes.get(requiredSize);
         if (!environments)
-            requiredWidths.set(requiredWidth, (environments = []));
-        environments.push({ name, width, index });
-        return requiredWidths;
+            requiredSizes.set(requiredSize, (environments = []));
+        environments.push({ name, width, height, index });
+        return requiredSizes;
     }, Promise.resolve(new Map()));
     const smallestBreakpoint = Math.min(...(isStrictBreakpoints ? settings.layoutBreakpoints.breakpoints : []));
-    if (isStrictBreakpoints && requiredWidths.has(smallestBreakpoint - 1)) {
+    const smallestSize = `${smallestBreakpoint - 1},${initialViewportSize.height}`;
+    if (isStrictBreakpoints && requiredSizes.has(smallestSize)) {
         const message = lang.requestedEnvironmentSmallerThenBreakpointWarning({
             breakpoint: smallestBreakpoint,
-            browsers: requiredWidths.get(smallestBreakpoint - 1),
+            browsers: requiredSizes.get(smallestSize),
         });
         logger.console.log(chalk_1.default.yellow(message));
     }
-    logger.log(`Taking multiple dom snapshots for the breakpoints`, settings.layoutBreakpoints);
-    const initialViewportSize = await driver.getViewportSize();
+    logger.log(`Taking multiple dom snapshots for the breakpoints`, isStrictBreakpoints ? settings.layoutBreakpoints : requiredSizes);
     const entries = [];
-    const initialsBrowsers = requiredWidths.get(initialViewportSize.width);
+    const initialSize = `${initialViewportSize.width},${initialViewportSize.height}`;
+    const initialsBrowsers = requiredSizes.get(initialSize);
     if (initialsBrowsers) {
         logger.log(`The first dom snapshot is going to be taking for initial viewport size`, initialViewportSize);
-        requiredWidths.delete(initialViewportSize.width);
+        requiredSizes.delete(initialSize);
         entries.push({ browsers: initialsBrowsers });
     }
-    requiredWidths.forEach((browsers, requiredWidth) => entries.push({ viewportSize: { width: requiredWidth, height: initialViewportSize.height }, browsers }));
+    requiredSizes.forEach((browsers, requiredSize) => {
+        const [requiredWidth, requiredHeight] = requiredSize.split(',').map(Number);
+        entries.push({ viewportSize: { width: requiredWidth, height: requiredHeight }, browsers });
+    });
     logger.log(`All entries to take dom snapshots for`, entries);
     // making safe selectors before any resize in order to make sure fallback selectors are created
     await (0, generate_safe_selectors_1.generateSafeSelectors)({

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-debug-20250429",
+  "version": "4.37.0-debug-20250429-3",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -75,7 +75,7 @@
     }
   },
   "dependencies": {
-    "@applitools/core-base": "1.24.0-debug-20250429",
+    "@applitools/core-base": "1.24.0-debug-20250429-1",
     "@applitools/dom-capture": "11.5.5",
     "@applitools/dom-snapshot": "4.11.18",
     "@applitools/driver": "1.21.1",

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;

package/types/ufg/check-and-close.d.ts

@@ -19,6 +19,7 @@ export declare function makeCheckAndClose<TSpec extends SpecType>({ eyes, target
         disableBrowserFetching?: boolean | undefined;
         layoutBreakpoints?: {
             breakpoints: boolean | number[];
+            heightBreakpoints?: boolean | undefined;
             reload?: boolean | undefined;
         } | undefined;
         hooks?: {

package/types/ufg/types.d.ts

@@ -54,6 +54,7 @@ export type SnapshotSettings<TSpec extends SpecType> = AutomationCore.CheckSetti
     disableBrowserFetching?: boolean;
     layoutBreakpoints?: {
         breakpoints: number[] | boolean;
+        heightBreakpoints?: boolean;
         reload?: boolean;
     };
     hooks?: {

package/types/ufg/utils/take-dom-snapshots.d.ts

@@ -10,6 +10,7 @@ export type DomSnapshotsSettings<TSpec extends SpecType> = DomSnapshotSettings<T
     waitBeforeCapture?: number | (() => Promise<void>);
     layoutBreakpoints?: {
         breakpoints: number[] | boolean;
+        heightBreakpoints?: boolean;
         reload?: boolean;
     };
     lazyLoad?: boolean | LazyLoadOptions;