testplane 9.0.0-rc.3 → 9.0.0

package/build/src/browser/client-scripts/screen-shooter/tsc-out/client-scripts/screen-shooter/operations.js

@@ -0,0 +1,633 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+exports.__esModule = true;
+exports.disablePointerEvents = exports.disableAnimations = exports.cleanupSavedScrolls = exports.prepareFullPageScrollCleanup = exports.saveScrollPositions = exports.scrollToCaptureAreaIfNeeded = exports.computePixelRatio = exports.computeCanHaveCaret = exports.computeDocumentSize = exports.computeSafeArea = exports.computeIgnoreAreas = exports.computeCaptureSpecs = exports.computeElementPositionsProbe = exports.computeViewportOffset = exports.computeViewportSize = exports.computeScrollOffset = void 0;
+var _isomorphic_1 = require("@isomorphic");
+var outside_of_viewport_1 = require("./errors/outside-of-viewport");
+var descriptions_1 = require("./utils/descriptions");
+var dom_1 = require("./utils/dom");
+var element_rect_1 = require("./utils/element-rect");
+var clip_rect_1 = require("./utils/clip-rect");
+var scroll_1 = require("./utils/scroll");
+var trusted_types_1 = require("./utils/trusted-types");
+var z_index_1 = require("./utils/z-index");
+var pseudo_element_rect_1 = require("./utils/pseudo-element-rect");
+var user_agent_1 = require("./utils/user-agent");
+function computeScrollOffset(element) {
+    return ((0, scroll_1.isRootLikeElement)(element) ? window.scrollY : element.scrollTop);
+}
+exports.computeScrollOffset = computeScrollOffset;
+function computeViewportSize() {
+    return {
+        width: window.innerWidth,
+        height: window.innerHeight
+    };
+}
+exports.computeViewportSize = computeViewportSize;
+function computeViewportOffset() {
+    return {
+        left: window.scrollX,
+        top: window.scrollY
+    };
+}
+exports.computeViewportOffset = computeViewportOffset;
+var ELEMENT_POSITIONS_PROBE_GRID_SIZE = 5;
+function getProbeAxisCoordinates(length, gridSize) {
+    var safeLength = Math.max(1, Math.floor(length));
+    if (gridSize <= 1) {
+        return [0];
+    }
+    var maxCoord = safeLength - 1;
+    var step = safeLength / (gridSize - 1);
+    var coordinates = [];
+    for (var i = 0; i < gridSize; i++) {
+        coordinates.push(Math.min(maxCoord, Math.round(i * step)));
+    }
+    return coordinates;
+}
+function computeElementPositionsProbe(gridSize) {
+    if (gridSize === void 0) { gridSize = ELEMENT_POSITIONS_PROBE_GRID_SIZE; }
+    var viewportSize = computeViewportSize();
+    var xCoordinates = getProbeAxisCoordinates(viewportSize.width, gridSize);
+    var yCoordinates = getProbeAxisCoordinates(viewportSize.height, gridSize);
+    var probe = [];
+    for (var yIndex = 0; yIndex < yCoordinates.length; yIndex++) {
+        for (var xIndex = 0; xIndex < xCoordinates.length; xIndex++) {
+            var x = xCoordinates[xIndex];
+            var y = yCoordinates[yIndex];
+            var element = document.elementFromPoint(x, y);
+            if (!element) {
+                probe.push(null);
+                continue;
+            }
+            probe.push(__assign(__assign({}, (0, _isomorphic_1.fromBcrToRect)(element.getBoundingClientRect())), { elementDescr: (0, descriptions_1.getReadableElementDescriptor)(element) }));
+        }
+    }
+    return probe;
+}
+exports.computeElementPositionsProbe = computeElementPositionsProbe;
+function computeCaptureSpecs(selectors, logger) {
+    if (selectors.length === 0) {
+        throw new Error("No selectors to compute capture area");
+    }
+    logger === null || logger === void 0 ? void 0 : logger("========== <computeCaptureSpecs> ==========");
+    logger === null || logger === void 0 ? void 0 : logger("selectors:", selectors);
+    var startTime = performance.now();
+    var elements = [];
+    for (var i = 0; i < selectors.length; i++) {
+        var parsedSelector = (0, pseudo_element_rect_1.parseCaptureSelector)(selectors[i]);
+        var element = document.querySelector(parsedSelector.elementSelector);
+        if (element) {
+            elements.push({ element: element, pseudoElement: parsedSelector.pseudoElement });
+        }
+    }
+    function getCaptureSpec(element, pseudoElement) {
+        var _a;
+        var full = pseudoElement
+            ? (0, element_rect_1.getPseudoElementCaptureRect)(element, pseudoElement)
+            : (0, element_rect_1.getElementCaptureRect)(element, logger);
+        if (!full)
+            return null;
+        var clip = (0, clip_rect_1.getClipRect)(element, logger);
+        var visible = (_a = (0, _isomorphic_1.getIntersection)(full, clip)) !== null && _a !== void 0 ? _a : {
+            top: full.top,
+            left: full.left,
+            width: 0,
+            height: 0
+        };
+        return { full: full, visible: visible, clip: clip };
+    }
+    var captureSpecs = [];
+    for (var _i = 0, elements_1 = elements; _i < elements_1.length; _i++) {
+        var _a = elements_1[_i], element = _a.element, pseudoElement = _a.pseudoElement;
+        var captureSpec = getCaptureSpec(element, pseudoElement);
+        if (captureSpec) {
+            captureSpecs.push(captureSpec);
+        }
+    }
+    logger === null || logger === void 0 ? void 0 : logger("captureSpecs:", captureSpecs);
+    logger === null || logger === void 0 ? void 0 : logger("computeCaptureSpecs time taken:", (performance.now() - startTime).toFixed(1) + "ms");
+    logger === null || logger === void 0 ? void 0 : logger("========== </computeCaptureSpecs> ==========");
+    return captureSpecs;
+}
+exports.computeCaptureSpecs = computeCaptureSpecs;
+function computeIgnoreAreas(selectors) {
+    if (selectors === void 0) { selectors = []; }
+    var ignoreAreas = [];
+    for (var s = 0; s < selectors.length; s++) {
+        var parsedSelector = (0, pseudo_element_rect_1.parseCaptureSelector)(selectors[s]);
+        var nodeList = document.querySelectorAll(parsedSelector.elementSelector);
+        for (var i = 0; i < nodeList.length; i++) {
+            var rect = parsedSelector.pseudoElement
+                ? (0, element_rect_1.getPseudoElementCaptureRect)(nodeList[i], parsedSelector.pseudoElement)
+                : (0, element_rect_1.getElementCaptureRect)(nodeList[i]);
+            if (rect !== null) {
+                ignoreAreas.push(rect);
+            }
+        }
+    }
+    return ignoreAreas;
+}
+exports.computeIgnoreAreas = computeIgnoreAreas;
+function computeSafeArea(selectorsToCapture, scrollElement, logger) {
+    var _a, _b;
+    logger === null || logger === void 0 ? void 0 : logger("========== <computeSafeArea> ==========");
+    var startTime = performance.now();
+    var viewportSize = computeViewportSize();
+    var viewportRect = {
+        left: 0,
+        top: 0,
+        width: viewportSize.width,
+        height: viewportSize.height
+    };
+    var captureElements = selectorsToCapture
+        .map(function (s) { return document.querySelector((0, pseudo_element_rect_1.parseCaptureSelector)(s).elementSelector); })
+        .filter(function (e) { return e !== null; });
+    var captureSpecs = computeCaptureSpecs(selectorsToCapture).map(function (s) { return s.full; });
+    if (captureSpecs.length === 0) {
+        return { top: viewportRect.top, height: viewportRect.height };
+    }
+    var scrollEl = scrollElement !== null && scrollElement !== void 0 ? scrollElement : document.documentElement;
+    // 1. Base safe area equals the visible rectangle of the scroll container
+    var safeArea;
+    if (scrollEl === document.documentElement) {
+        logger === null || logger === void 0 ? void 0 : logger("setting base safe area to viewport rect");
+        safeArea = __assign({}, viewportRect);
+    }
+    else {
+        var contentRect = (0, element_rect_1.getBoundingClientContentRect)(scrollEl);
+        logger === null || logger === void 0 ? void 0 : logger("setting base safe area to visible part of scroll container:", (0, descriptions_1.getReadableElementDescriptor)(scrollEl), "contentRect:", contentRect);
+        safeArea = (_a = (0, _isomorphic_1.getIntersection)(contentRect, viewportRect)) !== null && _a !== void 0 ? _a : __assign({}, viewportRect);
+        var _c = (0, element_rect_1.getVerticalRadiusInsets)(scrollEl), topRadiusInset = _c.top, bottomRadiusInset = _c.bottom;
+        if (topRadiusInset > 0 || bottomRadiusInset > 0) {
+            var safeAreaHeight = safeArea.height;
+            var topInset = Math.min(topRadiusInset, safeAreaHeight);
+            var bottomInset = Math.min(bottomRadiusInset, safeAreaHeight - topInset);
+            logger === null || logger === void 0 ? void 0 : logger("applying radius insets to safe area:", { topInset: topInset, bottomInset: bottomInset });
+            safeArea = __assign(__assign({}, safeArea), { top: (safeArea.top + topInset), height: (safeAreaHeight - topInset - bottomInset) });
+        }
+    }
+    var originalSafeArea = __assign({}, safeArea);
+    // 1.1 If all capture elements are fixed or inside non-scrollable fixed elements, scrolling will not move them,
+    // so no point in computing safe area
+    if (captureElements.every(function (el) {
+        return getComputedStyle(el).position === "fixed" ||
+            ((0, dom_1.findFixedPositionedParent)(el) !== null && (0, scroll_1.getScrollParent)(el) === null);
+    })) {
+        logger === null || logger === void 0 ? void 0 : logger("all capture elements are fixed or inside non-scrollable fixed subtree, skipping interferences");
+        return { top: originalSafeArea.top, height: originalSafeArea.height };
+    }
+    var captureArea = (0, _isomorphic_1.getCoveringRect)(captureSpecs);
+    // 2. Build z-index chains for all capture elements
+    //    One z-chain is a list of objects: { stacking context, z-index } -> { stacking context, z-index } -> ...
+    //    It is used to determine which element is on top of the other
+    var targetChains = captureElements.map(function (el) { return (0, z_index_1.buildZChain)(el); });
+    var captureLeft = captureArea.left;
+    var captureRight = captureLeft + captureArea.width;
+    // 3. Detect interfering elements
+    var interferences = [];
+    var allElements = document.documentElement.querySelectorAll("*");
+    var singleCaptureElement = captureElements.length === 1 ? captureElements[0] : null;
+    var _loop_1 = function (idx) {
+        var el = allElements[idx];
+        if (scrollEl === el || el.contains(scrollEl)) {
+            return "continue";
+        }
+        if (singleCaptureElement && (el === singleCaptureElement || el.contains(singleCaptureElement))) {
+            return "continue";
+        }
+        var computedStyle = getComputedStyle(el);
+        var position = computedStyle.position;
+        var bcr = el.getBoundingClientRect();
+        // Skip invisible elements
+        if (bcr.width < 1 ||
+            bcr.height < 1 ||
+            (bcr.width === 1 && bcr.height === 1) ||
+            computedStyle.visibility === "hidden" ||
+            computedStyle.display === "none" ||
+            parseFloat(computedStyle.opacity) < 0.0001 ||
+            /opacity\(\s*0(?:\.0+)?%?\s*\)/.test(computedStyle.filter))
+            return "continue";
+        // Skip elements that don't horizontally intersect with capture area
+        if (bcr.right <= captureLeft || bcr.left >= captureRight)
+            return "continue";
+        // Skip elements that are outside of viewport
+        if ((0, _isomorphic_1.getIntersection)((0, _isomorphic_1.fromBcrToRect)(bcr), viewportRect) === null)
+            return "continue";
+        var likelyInterferes = false;
+        var shouldSkipZIndexCheck = false;
+        var adjustedRect = (0, element_rect_1.domRectToViewportCss)(bcr);
+        var fixedPositionedParent = (0, dom_1.findFixedPositionedParent)(el);
+        var isInsideScrollContextFixedParent = fixedPositionedParent !== null &&
+            (fixedPositionedParent === scrollEl || fixedPositionedParent.contains(scrollEl));
+        if (position === "fixed" || (fixedPositionedParent && !isInsideScrollContextFixedParent)) {
+            likelyInterferes = true;
+            // If the fixed element is inside a capture element, it's almost certainly interfering
+            shouldSkipZIndexCheck = captureElements.some(function (capEl) { return capEl.contains(el); });
+        }
+        else if (position === "absolute") {
+            // Skip absolutely positioned elements that are inside capture elements
+            if (captureElements.some(function (capEl) { return capEl.contains(el); }))
+                return "continue";
+            // Absolute elements interfere only if positioned relative to ancestor outside scroll container
+            var containingBlock = (0, dom_1.findContainingBlock)(el);
+            // scrollElem may be window, in which case it doesn't have a contains method
+            if (scrollEl !== document.documentElement && !scrollEl.contains(containingBlock)) {
+                likelyInterferes = true;
+            }
+        }
+        else if (position === "sticky") {
+            // Sticky elements interfere based on their top/bottom values
+            var topValue = parseFloat(computedStyle.top);
+            var bottomValue = parseFloat(computedStyle.bottom);
+            var scrollParent = (_b = (0, scroll_1.getScrollParent)(el)) !== null && _b !== void 0 ? _b : document.documentElement;
+            logger === null || logger === void 0 ? void 0 : logger("scrollParent:", (0, descriptions_1.getReadableElementDescriptor)(scrollParent));
+            var scrollParentBcr = scrollParent.getBoundingClientRect();
+            topValue += (0, scroll_1.isRootLikeElement)(scrollParent) ? 0 : scrollParentBcr.top;
+            shouldSkipZIndexCheck =
+                scrollParent === scrollEl || ((0, scroll_1.isRootLikeElement)(scrollParent) && (0, scroll_1.isRootLikeElement)(scrollEl));
+            if (!isNaN(topValue)) {
+                adjustedRect = {
+                    left: bcr.left,
+                    top: topValue,
+                    width: bcr.width,
+                    height: bcr.height
+                };
+                likelyInterferes = true;
+            }
+            else if (!isNaN(bottomValue)) {
+                var isRoot = scrollEl === document.documentElement;
+                var viewportBottom = isRoot
+                    ? viewportRect.height
+                    : safeArea.top + safeArea.height;
+                adjustedRect = {
+                    left: bcr.left,
+                    top: (viewportBottom - bottomValue - bcr.height),
+                    width: bcr.width,
+                    height: bcr.height
+                };
+                likelyInterferes = true;
+            }
+        }
+        if (!likelyInterferes)
+            return "continue";
+        var candChain = (0, z_index_1.buildZChain)(el);
+        var behindAll = !shouldSkipZIndexCheck && targetChains.every(function (tChain) { return (0, z_index_1.isChainBehind)(candChain, tChain); });
+        if (!behindAll) {
+            var extRect = (0, element_rect_1.getExtRect)(computedStyle, adjustedRect);
+            var extLeft = extRect.left;
+            var extRight = extLeft + extRect.width;
+            if (extRight <= captureLeft || extLeft >= captureRight)
+                return "continue";
+            interferences.push({ element: el, rect: extRect });
+        }
+    };
+    for (var idx = 0; idx < allElements.length; idx++) {
+        _loop_1(idx);
+    }
+    var safeTop = safeArea.top;
+    var safeHeight = safeArea.height;
+    var origHeight = originalSafeArea.height;
+    // 4. Shrink safe area according to interfering elements
+    for (var _i = 0, interferences_1 = interferences; _i < interferences_1.length; _i++) {
+        var interference = interferences_1[_i];
+        logger === null || logger === void 0 ? void 0 : logger("processing interference:", {
+            element: (0, descriptions_1.getReadableElementDescriptor)(interference.element),
+            rect: interference.rect
+        });
+        var br = interference.rect;
+        var safeBottom = (0, _isomorphic_1.getBottom)({ top: safeTop, height: safeHeight });
+        var brBottom = (0, _isomorphic_1.getBottom)(br);
+        var shrinkTop = brBottom - safeTop;
+        var shrinkBottom = safeBottom - br.top;
+        var resultingTop = safeTop;
+        var resultingHeight = safeHeight;
+        if (shrinkTop < shrinkBottom) {
+            resultingTop = Math.max(brBottom, safeTop);
+            resultingHeight = (0, _isomorphic_1.getHeight)(safeBottom, resultingTop);
+            logger === null || logger === void 0 ? void 0 : logger("decided to shrink top");
+        }
+        else if (shrinkBottom) {
+            resultingHeight = Math.min(safeHeight, br.top - safeTop);
+            logger === null || logger === void 0 ? void 0 : logger("decided to shrink bottom");
+        }
+        // We don't want to shrink the safe area less than 30% of original height
+        if (resultingHeight < origHeight * 0.3) {
+            logger === null || logger === void 0 ? void 0 : logger("decided to skip, because shrinking is too large");
+            continue;
+        }
+        logger === null || logger === void 0 ? void 0 : logger("resulting safe area top:", resultingTop, "resulting safe area height:", resultingHeight);
+        safeTop = resultingTop;
+        safeHeight = resultingHeight;
+    }
+    // 5. Ensure we didn't shrink below 30% of original height
+    if (safeHeight < origHeight * 0.3) {
+        safeTop = originalSafeArea.top;
+        safeHeight = originalSafeArea.height;
+    }
+    // Safari on iOS 26 has a large blur at the bottom that interferes with scrolling, so
+    // if safe area ends too low, we shrink it by 40px which is enough to avoid the blur.
+    if ((0, user_agent_1.isSafariMobile)() && viewportSize.height - (safeTop + safeHeight) < 40) {
+        safeHeight = (safeHeight - 40);
+    }
+    var finalSafeArea = {
+        top: safeTop,
+        height: safeHeight
+    };
+    logger === null || logger === void 0 ? void 0 : logger("final safe area:", finalSafeArea);
+    logger === null || logger === void 0 ? void 0 : logger("computeSafeArea time taken:", (performance.now() - startTime).toFixed(1) + "ms");
+    logger === null || logger === void 0 ? void 0 : logger("========== </computeSafeArea> ==========");
+    return finalSafeArea;
+}
+exports.computeSafeArea = computeSafeArea;
+function computeDocumentSize() {
+    var mainDocumentElem = (0, dom_1.getMainDocumentElem)();
+    return {
+        width: mainDocumentElem.scrollWidth,
+        height: mainDocumentElem.scrollHeight
+    };
+}
+exports.computeDocumentSize = computeDocumentSize;
+function computeCanHaveCaret() {
+    var el = document.activeElement;
+    var canHaveCaret = el instanceof HTMLElement && (/^(input|textarea)$/i.test(el.tagName) || el.isContentEditable);
+    return canHaveCaret;
+}
+exports.computeCanHaveCaret = computeCanHaveCaret;
+function computePixelRatio(usePixelRatio) {
+    if (usePixelRatio === void 0) { usePixelRatio = true; }
+    if (usePixelRatio === false) {
+        return 1;
+    }
+    if (window.devicePixelRatio) {
+        return window.devicePixelRatio;
+    }
+    // for ie6-ie10 (https://developer.mozilla.org/ru/docs/Web/API/Window/devicePixelRatio)
+    // @ts-expect-error - IE hack
+    return window.screen.deviceXDPI / window.screen.logicalXDPI || 1;
+}
+exports.computePixelRatio = computePixelRatio;
+function scrollToCaptureAreaIfNeeded(selectorsToCapture, captureElementFromTop, allowViewportOverflow, selectorToScroll, logger) {
+    var viewportSize = computeViewportSize();
+    var viewport = __assign({ top: 0, left: 0 }, viewportSize);
+    var captureSpecsResult = computeCaptureSpecs(selectorsToCapture);
+    if (!captureSpecsResult)
+        return {};
+    var scrollTarget = selectorToScroll ? document.querySelector(selectorToScroll) : null;
+    var selectorsForScrollParentSearch = selectorsToCapture.map(function (selector) { return (0, pseudo_element_rect_1.parseCaptureSelector)(selector).elementSelector; });
+    var initialScrollElem = scrollTarget !== null && scrollTarget !== void 0 ? scrollTarget : (0, scroll_1.getCommonScrollParent)(selectorsForScrollParentSearch);
+    var readableSelectorToScrollDescr = selectorToScroll !== null && selectorToScroll !== void 0 ? selectorToScroll : (0, descriptions_1.getReadableElementDescriptor)(initialScrollElem);
+    var captureArea = (0, _isomorphic_1.getCoveringRect)(captureSpecsResult.map(function (s) { return s.full; }));
+    var safeArea = computeSafeArea(selectorsToCapture, initialScrollElem, logger);
+    var captureAndSafeAreasIntersection = (0, _isomorphic_1.getIntersection)(captureArea, safeArea);
+    var captureAndViewportIntersection = (0, _isomorphic_1.getIntersection)(captureArea, viewport);
+    var expectedVisibleHeight = Math.min(captureArea.height, safeArea.height);
+    var isIntersectionWithSafeAreaTooSmall = !captureAndSafeAreasIntersection || captureAndSafeAreasIntersection.height < expectedVisibleHeight / 2;
+    var isCaptureAreaStartVisible = captureArea.top >= safeArea.top;
+    logger === null || logger === void 0 ? void 0 : logger("scrollToCaptureAreaIfNeeded: intersection check", {
+        captureArea: captureArea,
+        safeArea: safeArea,
+        viewport: viewport,
+        hasViewportIntersection: Boolean(captureAndViewportIntersection),
+        hasSafeAreaIntersection: Boolean(captureAndSafeAreasIntersection),
+        isIntersectionWithSafeAreaTooSmall: isIntersectionWithSafeAreaTooSmall,
+        captureElementFromTop: Boolean(captureElementFromTop)
+    });
+    if (!captureElementFromTop && !captureAndViewportIntersection) {
+        logger === null || logger === void 0 ? void 0 : logger("scrollToCaptureAreaIfNeeded: throwing OutsideOfViewportError because captureElementFromTop is disabled and target is outside viewport");
+        throw new outside_of_viewport_1.OutsideOfViewportError();
+    }
+    if ((!captureElementFromTop || !isIntersectionWithSafeAreaTooSmall) && isCaptureAreaStartVisible) {
+        logger === null || logger === void 0 ? void 0 : logger("scrollToCaptureAreaIfNeeded: skipping scroll", {
+            reason: !captureElementFromTop
+                ? "captureElementFromTop is disabled"
+                : "target already has enough safe area visibility"
+        });
+        return {};
+    }
+    if (!captureElementFromTop && allowViewportOverflow) {
+        logger === null || logger === void 0 ? void 0 : logger("scrollToCaptureAreaIfNeeded: skipping scroll because allowViewportOverflow is true and captureElementFromTop is false");
+        return {};
+    }
+    logger === null || logger === void 0 ? void 0 : logger("scrollToCaptureAreaIfNeeded: scrolling is required", {
+        scrollElement: readableSelectorToScrollDescr,
+        requestedSelectorToScroll: selectorToScroll !== null && selectorToScroll !== void 0 ? selectorToScroll : null,
+        selectorMatched: Boolean(scrollTarget)
+    });
+    var scrollChain = __spreadArray([], (0, scroll_1.getScrollParentsChain)(initialScrollElem), true);
+    if (scrollChain[scrollChain.length - 1] !== initialScrollElem) {
+        scrollChain.push(initialScrollElem);
+    }
+    for (var i = 1; i < scrollChain.length; i++) {
+        var currentSafeArea = computeSafeArea(selectorsToCapture, scrollChain[i - 1]);
+        var childTop = scrollChain[i].getBoundingClientRect().top;
+        var scrollDelta = childTop - currentSafeArea.top;
+        logger === null || logger === void 0 ? void 0 : logger("scrollToCaptureAreaIfNeeded: scrolling chain element", {
+            scrollElement: (0, descriptions_1.getReadableElementDescriptor)(scrollChain[i - 1]),
+            childElement: (0, descriptions_1.getReadableElementDescriptor)(scrollChain[i]),
+            scrollDelta: scrollDelta
+        });
+        (0, scroll_1.scrollElementBy)(scrollChain[i - 1], scrollDelta, logger);
+    }
+    var finalCaptureArea = (0, _isomorphic_1.getCoveringRect)(computeCaptureSpecs(selectorsToCapture).map(function (s) { return s.full; }));
+    if (!finalCaptureArea)
+        return {};
+    var finalSafeArea = computeSafeArea(selectorsToCapture, initialScrollElem);
+    var finalScrollDelta = finalCaptureArea.top - finalSafeArea.top;
+    logger === null || logger === void 0 ? void 0 : logger("scrollToCaptureAreaIfNeeded: final alignment scroll", {
+        scrollElement: readableSelectorToScrollDescr,
+        finalScrollDelta: finalScrollDelta
+    });
+    (0, scroll_1.scrollElementBy)(initialScrollElem, finalScrollDelta, logger);
+    return {
+        readableSelectorToScrollDescr: readableSelectorToScrollDescr
+    };
+}
+exports.scrollToCaptureAreaIfNeeded = scrollToCaptureAreaIfNeeded;
+function saveElementScrollPosition(element) {
+    var namespaceData = (0, dom_1.getScreenshooterNamespaceData)();
+    if (!namespaceData.savedScrollPositions) {
+        namespaceData.savedScrollPositions = [];
+    }
+    if (namespaceData.savedScrollPositions.some(function (saved) { return saved.element === element; })) {
+        return;
+    }
+    var savedPosition = (0, scroll_1.isRootLikeElement)(element)
+        ? {
+            element: element,
+            left: window.scrollX,
+            top: window.scrollY
+        }
+        : {
+            element: element,
+            left: element.scrollLeft,
+            top: element.scrollTop
+        };
+    namespaceData.savedScrollPositions.push(savedPosition);
+}
+function saveScrollPositions(selectorsToCapture, selectorToScroll) {
+    (0, dom_1.getScreenshooterNamespaceData)().savedScrollPositions = [];
+    var scrollTarget = selectorToScroll ? document.querySelector(selectorToScroll) : null;
+    var selectorsForScrollParentSearch = selectorsToCapture.map(function (selector) { return (0, pseudo_element_rect_1.parseCaptureSelector)(selector).elementSelector; });
+    var initialScrollElement = scrollTarget !== null && scrollTarget !== void 0 ? scrollTarget : (0, scroll_1.getCommonScrollParent)(selectorsForScrollParentSearch);
+    var scrollChain = __spreadArray([], (0, scroll_1.getScrollParentsChain)(initialScrollElement), true);
+    if (scrollChain[scrollChain.length - 1] !== initialScrollElement) {
+        scrollChain.push(initialScrollElement);
+    }
+    for (var _i = 0, scrollChain_1 = scrollChain; _i < scrollChain_1.length; _i++) {
+        var scrollElement = scrollChain_1[_i];
+        saveElementScrollPosition(scrollElement);
+    }
+}
+exports.saveScrollPositions = saveScrollPositions;
+function prepareFullPageScrollCleanup() {
+    (0, dom_1.getScreenshooterNamespaceData)().savedScrollPositions = [];
+    saveElementScrollPosition(document.documentElement);
+}
+exports.prepareFullPageScrollCleanup = prepareFullPageScrollCleanup;
+function restoreScrollPosition(savedPosition) {
+    if ((0, scroll_1.isRootLikeElement)(savedPosition.element)) {
+        (0, scroll_1.performScrollFixForSafariIfNeeded)(savedPosition.top);
+        window.scrollTo(savedPosition.left, savedPosition.top);
+        return;
+    }
+    var scrollElement = savedPosition.element;
+    if (typeof scrollElement.scrollTo === "function") {
+        scrollElement.scrollTo(savedPosition.left, savedPosition.top);
+        return;
+    }
+    if (typeof scrollElement.scrollLeft === "number") {
+        scrollElement.scrollLeft = savedPosition.left;
+    }
+    if (typeof scrollElement.scrollTop === "number") {
+        scrollElement.scrollTop = savedPosition.top;
+    }
+}
+function cleanupSavedScrolls() {
+    var _a;
+    try {
+        var namespaceData = (0, dom_1.getScreenshooterNamespaceData)();
+        var savedScrollPositions = (_a = namespaceData.savedScrollPositions) !== null && _a !== void 0 ? _a : [];
+        namespaceData.savedScrollPositions = [];
+        for (var _i = 0, savedScrollPositions_1 = savedScrollPositions; _i < savedScrollPositions_1.length; _i++) {
+            var savedScrollPosition = savedScrollPositions_1[_i];
+            try {
+                restoreScrollPosition(savedScrollPosition);
+            }
+            catch (error) {
+                void error;
+            }
+        }
+    }
+    catch (error) {
+        void error;
+    }
+}
+exports.cleanupSavedScrolls = cleanupSavedScrolls;
+function disableAnimations() {
+    var everyElementSelector = "*:not(#testplane-q.testplane-w.testplane-e.testplane-r.testplane-t.testplane-y)";
+    var everythingSelector = ["", "::before", "::after"]
+        .map(function (pseudo) {
+        return everyElementSelector + pseudo;
+    })
+        .join(", ");
+    var styleElements = [];
+    function appendDisableAnimationStyleElement(root) {
+        var styleElement = document.createElement("style");
+        styleElement.innerHTML =
+            everythingSelector +
+                [
+                    "{",
+                    "    animation-delay: 0ms !important;",
+                    "    animation-duration: 0ms !important;",
+                    "    animation-timing-function: step-start !important;",
+                    "    transition-timing-function: step-start !important;",
+                    "    scroll-behavior: auto !important;",
+                    "    transition: none !important;",
+                    "}"
+                ].join("\n");
+        root.appendChild(styleElement);
+        styleElements.push(styleElement);
+    }
+    (0, dom_1.forEachRoot)(function (root) {
+        try {
+            appendDisableAnimationStyleElement(root);
+        }
+        catch (err) {
+            if (err &&
+                err.message &&
+                err.message.indexOf("This document requires 'TrustedHTML' assignment") !== -1) {
+                (0, trusted_types_1.createDefaultTrustedTypesPolicy)();
+                appendDisableAnimationStyleElement(root);
+            }
+            else {
+                throw err;
+            }
+        }
+    });
+    window.__cleanupAnimation = function () {
+        for (var i = 0; i < styleElements.length; i++) {
+            // IE11 doesn't have remove() on node
+            styleElements[i].parentNode.removeChild(styleElements[i]);
+        }
+        delete window.__cleanupAnimation;
+    };
+}
+exports.disableAnimations = disableAnimations;
+function disablePointerEvents() {
+    var everyElementSelector = "*:not(#testplane-q.testplane-w.testplane-e.testplane-r.testplane-t.testplane-y)";
+    var everythingSelector = ["", "::before", "::after"]
+        .map(function (pseudo) {
+        return everyElementSelector + pseudo;
+    })
+        .join(", ");
+    var styleElements = [];
+    function appendDisablePointerEventsStyleElement(root) {
+        var styleElement = document.createElement("style");
+        styleElement.innerHTML = everythingSelector + ["{", "    pointer-events: none !important;", "}"].join("\n");
+        root.appendChild(styleElement);
+        styleElements.push(styleElement);
+    }
+    (0, dom_1.forEachRoot)(function (root) {
+        try {
+            appendDisablePointerEventsStyleElement(root);
+        }
+        catch (err) {
+            if (err &&
+                err.message &&
+                err.message.indexOf("This document requires 'TrustedHTML' assignment") !== -1) {
+                (0, trusted_types_1.createDefaultTrustedTypesPolicy)();
+                appendDisablePointerEventsStyleElement(root);
+            }
+            else {
+                throw err;
+            }
+        }
+    });
+    var namespaceData = (0, dom_1.getScreenshooterNamespaceData)();
+    namespaceData.cleanupPointerEventsCb = function () {
+        for (var i = 0; i < styleElements.length; i++) {
+            styleElements[i].parentNode.removeChild(styleElements[i]);
+        }
+    };
+}
+exports.disablePointerEvents = disablePointerEvents;

package/build/src/browser/client-scripts/screen-shooter/tsc-out/client-scripts/screen-shooter/types.js

@@ -0,0 +1,2 @@
+"use strict";
+exports.__esModule = true;