@applitools/core 4.67.1 → 4.68.0

package/dist/figma/index.js

@@ -0,0 +1,27 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyFigmaBaselines = exports.runFigmaCheck = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./target-config"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./figma-images"), exports);
+__exportStar(require("./figma"), exports);
+var run_figma_check_1 = require("./run-figma-check");
+Object.defineProperty(exports, "runFigmaCheck", { enumerable: true, get: function () { return run_figma_check_1.runFigmaCheck; } });
+var seam_1 = require("./seam");
+Object.defineProperty(exports, "applyFigmaBaselines", { enumerable: true, get: function () { return seam_1.applyFigmaBaselines; } });

package/dist/figma/run-figma-check.js

@@ -0,0 +1,82 @@
+"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.runFigmaCheck = void 0;
+const utils = __importStar(require("@applitools/utils"));
+const core_1 = require("../core");
+// Cached because this runs once per open — eyes-storybook opens per story, and a fresh Core each time
+// re-initialises and forfeits HTTP agent reuse. Safe to share: all state arrives via `openEyes`.
+const getFigmaCore = utils.general.cachify(() => (0, core_1.makeCore)({ agentId: 'core.figma-baseline' }));
+/**
+ * Establishes/updates the Figma-reference baseline via a throwaway headless classic image test (checks
+ * each PNG, closes, deletes the result — the saved baseline persists). Uses core's own API, not the
+ * eyes layer (core cannot depend on `@applitools/eyes`).
+ */
+async function runFigmaCheck(config, checks) {
+    var _a;
+    const core = getFigmaCore();
+    const eyes = await core.openEyes({
+        type: 'classic',
+        settings: {
+            appName: config.appName,
+            testName: config.testName,
+            apiKey: config.apiKey,
+            eyesServerUrl: config.eyesServerUrl,
+            proxy: config.proxy,
+            baselineEnvName: config.baselineEnvName,
+            properties: config.properties,
+            batch: config.batch,
+            keepBatchOpen: config.keepBatchOpen,
+            saveDiffs: config.saveDiffs,
+            ...(config.branchName !== undefined ? { branchName: config.branchName } : {}),
+            environment: config.environment,
+            // Throwaway reference test keyed purely by baselineEnvName; skip the (slow) git extraction.
+            ignoreGitBranching: true,
+        },
+    });
+    for (const { imagePath, tag } of checks) {
+        await eyes.check({ target: { image: imagePath }, settings: { name: tag } });
+    }
+    // core's close-time equivalent of saveNewTests (defaulted true there too).
+    await eyes.close({ settings: { updateBaselineIfNew: (_a = config.saveNewTests) !== null && _a !== void 0 ? _a : true } });
+    const [result] = await eyes.getResults({ settings: { throwErr: false } });
+    try {
+        await core.deleteTest({
+            settings: {
+                testId: result.id,
+                batchId: result.batchId,
+                secretToken: result.secretToken,
+                eyesServerUrl: result.eyesServer.eyesServerUrl,
+                apiKey: result.eyesServer.apiKey,
+                proxy: result.eyesServer.proxy,
+            },
+        });
+    }
+    catch {
+        // best-effort cleanup
+    }
+    return { isNew: result.isNew, diffs: result.mismatches > 0 };
+}
+exports.runFigmaCheck = runFigmaCheck;

package/dist/figma/seam.js

@@ -0,0 +1,91 @@
+"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.applyFigmaBaselines = void 0;
+const utils = __importStar(require("@applitools/utils"));
+const figma_1 = require("./figma");
+const utils_1 = require("./utils");
+/**
+ * @internal
+ * Resolves the `figmaBaselines` / `figmaOptions` open config once per open, then always strips both — they
+ * are off-the-wire and must never be logged or sent. The resolver mutates `settings` in place.
+ *
+ * The only place the Figma feature reads the environment; everything below it takes parameters. Each
+ * `figmaOptions` field wins over its env fallback.
+ */
+async function applyFigmaBaselines(settings, logger, resolve = figma_1.setFigmaBaseline) {
+    var _a, _b, _c, _d, _e, _f;
+    const figmaBaselines = settings.figmaBaselines;
+    const figmaOptions = (_a = settings.figmaOptions) !== null && _a !== void 0 ? _a : {};
+    if (!figmaBaselines) {
+        // Undefined-valued keys must not survive to the wire/log.
+        delete settings.figmaBaselines;
+        delete settings.figmaOptions;
+        return;
+    }
+    try {
+        // A shared open config applies to every test, so an unmapped test must not fail — only skip.
+        if (typeof figmaBaselines !== 'string' && figmaBaselines[settings.testName] === undefined) {
+            logger.warn(`figmaBaselines is set but has no entry for test "${settings.testName}"; skipping Figma baseline resolution for this test.`);
+            return;
+        }
+        // skipApi has no figmaOptions equivalent by design — CI/debug switch, not a user option.
+        const skipApi = (_b = utils.general.getEnvValue('FIGMA_SKIP_API', 'boolean')) !== null && _b !== void 0 ? _b : false;
+        const envTtl = utils.general.getEnvValue('FIGMA_NODES_CACHE_TTL', 'number');
+        const tempPath = (_c = figmaOptions.tempPath) !== null && _c !== void 0 ? _c : utils.general.getEnvValue('FIGMA_TEMP_PATH');
+        // A long TTL lets a pre-warmed cache (committed fixtures) serve through the normal cache-hit path
+        // instead of the all-or-nothing skipApi bypass. Number.isFinite also rejects a non-numeric env value.
+        const nodesCacheTtlSeconds = (_d = figmaOptions.nodesCacheTtlSeconds) !== null && _d !== void 0 ? _d : envTtl;
+        // Registered with the logger the way apiKey/secretToken are elsewhere, so a token supplied through
+        // figmaOptions is redacted wherever settings are logged downstream.
+        const accessToken = (_e = figmaOptions.accessToken) !== null && _e !== void 0 ? _e : process.env.FIGMA_ACCESS_TOKEN;
+        if (accessToken)
+            logger.mask(accessToken);
+        await resolve(settings, figmaBaselines, {
+            logger,
+            skipApi,
+            mode: (0, utils_1.resolveFigmaMode)((_f = figmaOptions.mode) !== null && _f !== void 0 ? _f : utils.general.getEnvValue('FIGMA_MODE')),
+            accessToken,
+            // On-prem accounts have no direct route to api.figma.com.
+            proxy: settings.proxy,
+            ...(tempPath ? { tempPath } : {}),
+            ...(Number.isFinite(nodesCacheTtlSeconds) ? { nodesCacheTtlSeconds } : {}),
+            // These three have no env fallback, so omit them when absent and let the resolver default them.
+            // `!= null` not `!== undefined`: bindings that serialize an unset nested field as null (Ruby) would
+            // otherwise reach `maxRateLimitWaitSeconds = 60`, which only defaults on undefined, and null*1000
+            // silently zeroes the rate-limit budget.
+            ...(figmaOptions.maxRateLimitWaitSeconds != null
+                ? { maxRateLimitWaitSeconds: figmaOptions.maxRateLimitWaitSeconds }
+                : {}),
+            ...(figmaOptions.maxViewportHeight != null ? { maxViewportHeight: figmaOptions.maxViewportHeight } : {}),
+            ...(figmaOptions.minViewportSize != null ? { minViewportSize: figmaOptions.minViewportSize } : {}),
+        });
+    }
+    finally {
+        delete settings.figmaBaselines;
+        delete settings.figmaOptions;
+    }
+}
+exports.applyFigmaBaselines = applyFigmaBaselines;

package/dist/figma/target-config.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTargetTestConfig = exports.deduplicateBrowsers = exports.PLACEHOLDER_TAG = exports.DEFAULT_MAX_VIEWPORT_HEIGHT = void 0;
+const utils_1 = require("./utils");
+// Default height cap (overridable via opts.maxViewportHeight): designs can be arbitrarily tall, so
+// height is capped but width never is — width is the form factor the design and real test must share.
+exports.DEFAULT_MAX_VIEWPORT_HEIGHT = 800;
+// Dashboard tag for a '' (placeholder) step; real steps use the Figma URL as the tag.
+exports.PLACEHOLDER_TAG = '(no design)';
+// UFG opens request per-browser environments; classic sizes a single viewport instead.
+function deduplicateBrowsers(environments, targetWidth, targetHeight) {
+    const desktop = new Map();
+    for (const environment of environments) {
+        const db = environment;
+        const entry = typeof db.width === 'number'
+            ? db
+            : { name: 'iosDeviceInfo' in environment ? 'safari' : 'chrome', width: targetWidth, height: targetHeight };
+        desktop.set(String(entry.name), { ...entry, width: targetWidth, height: targetHeight });
+    }
+    return [...desktop.values()];
+}
+exports.deduplicateBrowsers = deduplicateBrowsers;
+// baselineLink is null in "test-baseline" mode: baselineEnvName is left untouched (no change detection
+// happened to justify linking), but viewport/properties are still adjusted. figmaViewport always wins.
+function buildTargetTestConfig(originalConfig, metadata, figmaViewport, baselineLink, mode) {
+    var _a, _b, _c;
+    const isUFG = ((_b = (_a = originalConfig.environments) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0;
+    const mergedProperties = [...((_c = originalConfig.properties) !== null && _c !== void 0 ? _c : []), ...(0, utils_1.figmaMetadataToProperties)(metadata, mode)];
+    // baselineEnvOptions is the internal field backing Configuration.setBaselineEnvName(name, {useLatestEnvBaseline}) — same effect without a live Configuration.
+    const baselineFields = baselineLink
+        ? {
+            baselineEnvName: baselineLink.figmaEnvName,
+            baselineEnvOptions: { useLatestEnvBaseline: baselineLink.useLatestEnvBaseline },
+        }
+        : {};
+    // The figma viewport always wins; merged into environment.viewportSize so os/hostingApp survive.
+    const environment = { ...originalConfig.environment, viewportSize: figmaViewport };
+    if (isUFG) {
+        return {
+            ...baselineFields,
+            properties: mergedProperties,
+            environments: deduplicateBrowsers(originalConfig.environments, figmaViewport.width, figmaViewport.height),
+            environment,
+        };
+    }
+    return {
+        ...baselineFields,
+        properties: mergedProperties,
+        environment,
+    };
+}
+exports.buildTargetTestConfig = buildTargetTestConfig;

package/dist/figma/types.js

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

package/dist/figma/utils.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paddedDesignSize = exports.computeFigmaViewport = exports.boundingViewport = exports.figmaMetadataToProperties = exports.resolveFigmaMode = exports.FIGMA_MODES = exports.resolveFigmaUrls = exports.figmaStepTag = exports.parseFigmaNodeUrl = exports.isFigmaUrl = void 0;
+// ---------------------------------------------------------------------------
+// URL detection and parsing
+// ---------------------------------------------------------------------------
+function isFigmaUrl(url) {
+    try {
+        const { hostname } = new URL(url);
+        return hostname === 'figma.com' || hostname === 'www.figma.com';
+    }
+    catch {
+        return false;
+    }
+}
+exports.isFigmaUrl = isFigmaUrl;
+function parseFigmaNodeUrl(url) {
+    let u;
+    try {
+        u = new URL(url);
+    }
+    catch {
+        throw new Error(`Invalid URL: "${url}"`);
+    }
+    if (!isFigmaUrl(url)) {
+        throw new Error(`Not a Figma URL: "${url}"`);
+    }
+    // Pathname: /{type}/{fileId}/{title}  e.g. /design/abc123/Untitled
+    const segments = u.pathname.split('/').filter(Boolean);
+    const fileId = segments[1];
+    if (!fileId) {
+        throw new Error(`Could not extract file ID from Figma URL: "${url}"`);
+    }
+    const rawNodeId = u.searchParams.get('node-id');
+    if (!rawNodeId) {
+        throw new Error(`No node-id parameter in Figma URL: "${url}"`);
+    }
+    // Figma encodes "1:2" as "1-2" in URLs; %3A is decoded to ":" automatically by URLSearchParams
+    const nodeId = rawNodeId.includes(':') ? rawNodeId : rawNodeId.replace('-', ':');
+    return { fileId, nodeId };
+}
+exports.parseFigmaNodeUrl = parseFigmaNodeUrl;
+/**
+ * The tag becomes the Eyes baseline step name, and Eyes matches steps by name, so it must derive only from
+ * stable identity. Figma's "Copy link to selection" appends a `t=` param that differs on every copy —
+ * keeping it means re-copying the link renames the step and orphans its accepted baseline.
+ *
+ * Drop only `t`: `node-id` is what distinguishes two frames of the same file, so stripping the whole query
+ * would give every frame in a file the same step name.
+ */
+function figmaStepTag(figmaUrl) {
+    const url = new URL(figmaUrl);
+    url.searchParams.delete('t');
+    return url.toString();
+}
+exports.figmaStepTag = figmaStepTag;
+// ---------------------------------------------------------------------------
+// figmaBaselines / mode resolution
+// ---------------------------------------------------------------------------
+// Resolves figmaBaselines + testName to the list of Figma URLs, or null when the test opts out.
+function resolveFigmaUrls(figmaBaselines, testName) {
+    if (typeof figmaBaselines === 'string') {
+        return figmaBaselines === '' ? null : [figmaBaselines];
+    }
+    // No testName (should be set upstream) → no matching entry → falls through to the no-entry throw below.
+    const entry = testName === undefined ? undefined : figmaBaselines[testName];
+    if (entry === '' || (Array.isArray(entry) && entry.length === 0))
+        return null;
+    // An all-'' array (no real design anywhere) is treated as a missing entry, not an opt-out.
+    const isAllPlaceholders = Array.isArray(entry) && entry.every((url) => url === '');
+    if (entry === undefined || isAllPlaceholders) {
+        throw new Error(`setFigmaBaseline: no Figma URL configured for test "${testName}". ` +
+            `Add an entry in the figmaBaselines config option.`);
+    }
+    return Array.isArray(entry) ? entry : [entry];
+}
+exports.resolveFigmaUrls = resolveFigmaUrls;
+exports.FIGMA_MODES = ['figma-baseline', 'test-baseline', 'auto-baseline', 'disabled'];
+// The value can arrive from figmaOptions.mode or the env var, so the error names both.
+function resolveFigmaMode(value) {
+    if (value === undefined)
+        return 'auto-baseline';
+    if (!exports.FIGMA_MODES.includes(value)) {
+        throw new Error(`setFigmaBaseline: invalid Figma mode "${value}". Expected one of: ${exports.FIGMA_MODES.join(', ')}. ` +
+            `Set it via figmaOptions.mode or APPLITOOLS_FIGMA_MODE.`);
+    }
+    return value;
+}
+exports.resolveFigmaMode = resolveFigmaMode;
+// figma:mode is last because the cross-language generic tests assert the earlier properties by index —
+// emitters can only translate index access, not a lookup by name. Reordering breaks 4 languages' CI.
+function figmaMetadataToProperties(metadata, mode) {
+    return [
+        { name: 'figma:name', value: metadata.name },
+        { name: 'figma:type', value: metadata.type },
+        { name: 'figma:file-revision', value: metadata.revision },
+        { name: 'figma:file-last-modified', value: metadata.lastModifiedAt },
+        { name: 'figma:mode', value: mode },
+    ];
+}
+exports.figmaMetadataToProperties = figmaMetadataToProperties;
+// ---------------------------------------------------------------------------
+// Viewport math
+// ---------------------------------------------------------------------------
+// The smallest box that fits every given viewport (max width, max height).
+function boundingViewport(viewports) {
+    return {
+        width: Math.max(...viewports.map(v => v.width)),
+        height: Math.max(...viewports.map(v => v.height)),
+    };
+}
+exports.boundingViewport = boundingViewport;
+// THE figma viewport: bounding box across every step, height capped at maxViewportHeight. Drives the
+// baseline env label, the reference Eyes session, and the user's test viewport — so everything renders at one size.
+function computeFigmaViewport(stepViewports, maxViewportHeight) {
+    const bounds = boundingViewport(stepViewports);
+    return { width: bounds.width, height: Math.min(bounds.height, maxViewportHeight) };
+}
+exports.computeFigmaViewport = computeFigmaViewport;
+// minViewportSize floors a design's dimensions so a consumer with a minimum viewport (e.g. the UFG on a
+// small Storybook component) won't reject it; padding centers the design on a >=minSize white canvas.
+function paddedDesignSize(width, height, minSize) {
+    return {
+        width: Math.max(width, minSize),
+        height: Math.max(height, minSize),
+    };
+}
+exports.paddedDesignSize = paddedDesignSize;

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

@@ -31,6 +31,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const core_1 = require("../core");
 const get_ufg_client_1 = require("../ufg/get-ufg-client");
+const build_accessibility_report_options_1 = require("../ufg/build-accessibility-report-options");
 const to_base_check_settings_1 = require("../automation/utils/to-base-check-settings");
 const logger_1 = require("@applitools/logger");
 const chalk_1 = __importDefault(require("chalk"));
@@ -63,7 +64,13 @@ async function runOfflineSnapshots(options) {
     const offlineLocationPath = path_1.default.resolve(options.offlineLocationPath);
     const startTime = Date.now();
     const logger = (_a = options.logger) !== null && _a !== void 0 ? _a : (0, logger_1.makeLogger)({ format: { label: 'offline-exec' } });
-    const eyesServerSettings = { ...options.config.open, ...options };
+    // figmaBaselines/figmaOptions are off-the-wire open config that the open seam resolves and then strips.
+    // This replay path bypasses the seam, so strip them once here — figmaOptions carries a Figma access
+    // token, and getAccountInfo logs the settings it is called with.
+    const openConfig = { ...options.config.open };
+    delete openConfig.figmaBaselines;
+    delete openConfig.figmaOptions;
+    const eyesServerSettings = { ...openConfig, ...options };
     const core = (0, core_1.makeCore)({ agentId: `js/core-offline/${version()}`, logger });
     const account = await core.getAccountInfo({ settings: eyesServerSettings });
     const ufgClient = await (0, get_ufg_client_1.makeGetUFGClient)({ logger })({
@@ -111,7 +118,7 @@ async function runOfflineSnapshots(options) {
             const fileOpenSettings = await fs_1.default.promises
                 .readFile(path_1.default.join(testPath, 'settings.json'), 'utf-8')
                 .then(JSON.parse);
-            const openSettings = (0, merge_configs_1.mergeConfigs)(fileOpenSettings, options.config.open);
+            const openSettings = (0, merge_configs_1.mergeConfigs)(fileOpenSettings, openConfig);
             messages.push(`Running test: ${openSettings.testName} (${formatEnvironment(openSettings.environment)})`);
             return { testPath, openSettings, testLogger };
         });
@@ -336,10 +343,14 @@ async function runOfflineSnapshots(options) {
         });
     }
     async function render(target, logger) {
-        var _a;
+        var _a, _b;
         const { elementReferences: selectors, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({
             settings: target.settings,
         });
+        // Only request a report when the check configures an accessibility standard.
+        const accessibilityReportOptions = target.settings.accessibilitySettings
+            ? (0, build_accessibility_report_options_1.buildAccessibilityReportOptions)({ accessibilityOptions: account.accessibilityOptions })
+            : undefined;
         const { renderId, selectorRegions, ...baseTarget } = await ufgClient.render({
             target: target.target,
             settings: {
@@ -351,6 +362,7 @@ async function runOfflineSnapshots(options) {
                 environment: target.settings.environment,
                 uploadUrl: account.uploadUrl,
                 stitchingServiceUrl: account.stitchingServiceUrl,
+                accessibilityReportOptions,
             },
             logger,
         });
@@ -365,6 +377,9 @@ async function runOfflineSnapshots(options) {
         baseSettings.renderId = renderId;
         // baseSettings.stepIndex = index
         baseTarget.source = target.target.source; // TODO verify
+        // Fall back to the minted upload URL when the render result carries no report location.
+        if (accessibilityReportOptions === null || accessibilityReportOptions === void 0 ? void 0 : accessibilityReportOptions.uploadUrl)
+            (_b = baseTarget.accessibilityReportLocation) !== null && _b !== void 0 ? _b : (baseTarget.accessibilityReportLocation = accessibilityReportOptions.uploadUrl);
         // baseTarget.name = snapshot.title // TODO figure out
         const mergedCheckSettings = (0, merge_configs_1.mergeConfigs)(baseSettings, options.config.check);
         return { mergedCheckSettings, baseTarget };

package/dist/open-eyes.js

@@ -33,6 +33,7 @@ const check_and_close_1 = require("./check-and-close");
 const close_1 = require("./close");
 const abort_1 = require("./abort");
 const get_eyes_results_1 = require("./get-eyes-results");
+const seam_1 = require("./figma/seam");
 const populate_eyes_server_settings_1 = require("./utils/populate-eyes-server-settings");
 const utils = __importStar(require("@applitools/utils"));
 const core_base_1 = require("@applitools/core-base");
@@ -110,6 +111,7 @@ function makeOpenEyes({ type: defaultType = 'classic', clients, batch, removeDup
             logger.warn(`gitBranchingTimestamp is an invalid ISO date string: ${settings.gitBranchingTimestamp}`);
             settings.gitBranchingTimestamp = undefined;
         }
+        await (0, seam_1.applyFigmaBaselines)(settings, logger);
         (_x = settings.bypassCSP) !== null && _x !== void 0 ? _x : (settings.bypassCSP = utils.general.getEnvValue('BYPASS_CSP', 'boolean') === true || undefined);
         const driver = target && (await (0, driver_1.makeDriver)({ spec, driver: target, logger, customConfig: settings }));
         if (settings.bypassCSP) {

package/dist/ufg/build-accessibility-report-options.js

@@ -0,0 +1,40 @@
+"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.buildAccessibilityReportOptions = void 0;
+const utils = __importStar(require("@applitools/utils"));
+const REPORT_ID_PLACEHOLDER = '__report_id__';
+/**
+ * Builds the `accessibilityReportOptions` render option: forwards `runOptions` verbatim and fills the
+ * `uploadUrl` template's `__report_id__` with a fresh random id. Returns `undefined` when the account
+ * has no accessibility options.
+ */
+function buildAccessibilityReportOptions({ accessibilityOptions, reportId = utils.general.guid(), }) {
+    if (!accessibilityOptions)
+        return undefined;
+    const uploadUrl = accessibilityOptions.uploadUrl.split(REPORT_ID_PLACEHOLDER).join(encodeURIComponent(reportId));
+    return { axeCoreOptions: accessibilityOptions.runOptions, uploadUrl };
+}
+exports.buildAccessibilityReportOptions = buildAccessibilityReportOptions;

package/dist/ufg/check-and-close.js

@@ -37,6 +37,7 @@ const lang = __importStar(require("../lang"));
 const chalk_1 = __importDefault(require("chalk"));
 const take_snapshots_1 = require("./take-snapshots");
 const create_render_target_from_snapshot_1 = require("./create-render-target-from-snapshot");
+const build_accessibility_report_options_1 = require("./build-accessibility-report-options");
 function makeCheckAndClose({ eyes, target: defaultTarget, environments: defaultEnvironments = [], spec, signal, logger: mainLogger, }) {
     return async function checkAndClose({ target = defaultTarget, settings = {}, logger = mainLogger, } = {}) {
         var _a;
@@ -72,7 +73,7 @@ function makeCheckAndClose({ eyes, target: defaultTarget, environments: defaultE
             snapshots = !utils.types.isArray(target) ? Array(uniqueEnvironments.length).fill(target) : target;
         }
         const promises = snapshots.map(async (snapshot, i) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
             const environmentLogger = logger.extend({ tags: [`environment-${utils.general.shortid()}`] });
             const { target } = snapshot;
             const environment = uniqueEnvironments[i];
@@ -115,6 +116,10 @@ function makeCheckAndClose({ eyes, target: defaultTarget, environments: defaultE
                     const { elementReferences: selectors, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({
                         settings: snapshot.settings,
                     });
+                    // Only request a report when the check configures an accessibility standard.
+                    const accessibilityReportOptions = settings.accessibilitySettings
+                        ? (0, build_accessibility_report_options_1.buildAccessibilityReportOptions)({ accessibilityOptions: eyes.test.account.accessibilityOptions })
+                        : undefined;
                     const { renderId, selectorRegions, ...baseTarget } = await ufgClient.render({
                         target: renderTarget,
                         settings: {
@@ -126,6 +131,7 @@ function makeCheckAndClose({ eyes, target: defaultTarget, environments: defaultE
                             environment: { ...environment, environmentId: baseEyes.test.environment.environmentId },
                             uploadUrl: baseEyes.test.uploadUrl,
                             stitchingServiceUrl: baseEyes.test.stitchingServiceUrl,
+                            accessibilityReportOptions,
                         },
                         signal,
                         logger: environmentLogger,
@@ -141,13 +147,16 @@ function makeCheckAndClose({ eyes, target: defaultTarget, environments: defaultE
                     baseSettings.renderId = renderId;
                     baseTarget.source = snapshot.url;
                     baseTarget.name = snapshot.title;
+                    // Fall back to the minted upload URL when the render result carries no report location.
+                    if (accessibilityReportOptions === null || accessibilityReportOptions === void 0 ? void 0 : accessibilityReportOptions.uploadUrl)
+                        (_f = baseTarget.accessibilityReportLocation) !== null && _f !== void 0 ? _f : (baseTarget.accessibilityReportLocation = accessibilityReportOptions.uploadUrl);
                     if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                         environmentLogger.warn('Command "check" was aborted after rendering');
                         throw new abort_error_1.AbortError('Command "check" was aborted after rendering');
                     }
                     else if (!baseEyes.running) {
-                        environmentLogger.warn(`Render on environment with id "${(_f = baseEyes.test.environment) === null || _f === void 0 ? void 0 : _f.environmentId}" was aborted during one of the previous steps`);
-                        throw new abort_error_1.AbortError(`Render on environment with id "${(_g = baseEyes.test.environment) === null || _g === void 0 ? void 0 : _g.environmentId}" was aborted during one of the previous steps`);
+                        environmentLogger.warn(`Render on environment with id "${(_g = baseEyes.test.environment) === null || _g === void 0 ? void 0 : _g.environmentId}" was aborted during one of the previous steps`);
+                        throw new abort_error_1.AbortError(`Render on environment with id "${(_h = baseEyes.test.environment) === null || _h === void 0 ? void 0 : _h.environmentId}" was aborted during one of the previous steps`);
                     }
                     if (settings.assumesMutability) {
                         void eyes.core.logEvent({
@@ -165,7 +174,7 @@ function makeCheckAndClose({ eyes, target: defaultTarget, environments: defaultE
                                         userTestId: baseEyes.test.userTestId,
                                         appId: baseEyes.test.appId,
                                         baselineId: baseEyes.test.baselineId,
-                                        environmentId: (_h = baseEyes.test.environment) === null || _h === void 0 ? void 0 : _h.environmentId,
+                                        environmentId: (_j = baseEyes.test.environment) === null || _j === void 0 ? void 0 : _j.environmentId,
                                     },
                                     isNew: baseEyes.test.isNew,
                                     resultsUrl: baseEyes.test.resultsUrl,
@@ -182,7 +191,7 @@ function makeCheckAndClose({ eyes, target: defaultTarget, environments: defaultE
                     });
                 }
                 catch (error) {
-                    environmentLogger.error(`Render on environment with id "${(_j = baseEyes.test.environment) === null || _j === void 0 ? void 0 : _j.environmentId}" failed due to an error`, error);
+                    environmentLogger.error(`Render on environment with id "${(_k = baseEyes.test.environment) === null || _k === void 0 ? void 0 : _k.environmentId}" failed due to an error`, error);
                     if (baseEyes.running && !(signal === null || signal === void 0 ? void 0 : signal.aborted))
                         await baseEyes.abort({ logger: environmentLogger, settings: { reason: error } });
                 }

package/dist/ufg/check.js

@@ -38,6 +38,7 @@ const take_snapshots_1 = require("./take-snapshots");
 const create_render_target_from_snapshot_1 = require("./create-render-target-from-snapshot");
 const to_base_check_settings_1 = require("../automation/utils/to-base-check-settings");
 const to_old_infra_environment_1 = require("./to-old-infra-environment");
+const build_accessibility_report_options_1 = require("./build-accessibility-report-options");
 function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironments = [], spec, signal, logger: mainLogger, }) {
     // Sessions whose old-infra retry chain has ended: once a retry doesn't confirm an old-infra match,
     // the backend stops expecting retries, so we must stop sending them. baseEyes is cached per
@@ -122,7 +123,11 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
                         settings: snapshot.settings,
                     });
                     const renderForCheck = async (env) => {
-                        var _a;
+                        var _a, _b;
+                        // Only request a report when the check configures an accessibility standard.
+                        const accessibilityReportOptions = settings.accessibilitySettings
+                            ? (0, build_accessibility_report_options_1.buildAccessibilityReportOptions)({ accessibilityOptions: eyes.test.account.accessibilityOptions })
+                            : undefined;
                         const { renderId, selectorRegions, ...target } = await ufgClient.render({
                             target: renderTarget,
                             settings: {
@@ -134,6 +139,7 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
                                 environment: { ...env, environmentId: baseEyes.test.environment.environmentId },
                                 uploadUrl: baseEyes.test.uploadUrl,
                                 stitchingServiceUrl: baseEyes.test.stitchingServiceUrl,
+                                accessibilityReportOptions,
                             },
                             signal,
                             logger: environmentLogger,
@@ -149,6 +155,9 @@ function makeCheck({ eyes, target: defaultTarget, environments: defaultEnvironme
                         checkSettings.renderId = renderId;
                         target.source = snapshot.url;
                         target.name = snapshot.title;
+                        // Fall back to the minted upload URL when the render result carries no report location.
+                        if (accessibilityReportOptions === null || accessibilityReportOptions === void 0 ? void 0 : accessibilityReportOptions.uploadUrl)
+                            (_b = target.accessibilityReportLocation) !== null && _b !== void 0 ? _b : (target.accessibilityReportLocation = accessibilityReportOptions.uploadUrl);
                         return { target, settings: checkSettings };
                     };
                     const { target: baseTarget, settings: baseSettings } = await renderForCheck(environment);