@shopify/jest-dom-mocks/dist/intersection-observer.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = require("tslib");
var IntersectionObserverMock = /** @class */ (function () {
    function IntersectionObserverMock() {
        this.observers = [];
        this.isUsingMockIntersectionObserver = false;
        this.originalIntersectionObserver = global.IntersectionObserver;
        this.originalIntersectionObserverEntry = global
            .IntersectionObserverEntry;
    }
    IntersectionObserverMock.prototype.simulate = function (entry) {
        var e_1, _a;
        this.ensureMocked();
        var arrayOfEntries = Array.isArray(entry) ? entry : [entry];
        var targets = arrayOfEntries.map(function (_a) {
            var target = _a.target;
            return target;
        });
        var noCustomTargets = targets.every(function (target) { return target == null; });
        var _loop_1 = function (observer) {
            if (noCustomTargets || targets.includes(observer.target)) {
                observer.callback(arrayOfEntries.map(function (entry) { return normalizeEntry(entry, observer.target); }), observer);
            }
        };
        try {
            for (var _b = tslib_1.__values(this.observers), _c = _b.next(); !_c.done; _c = _b.next()) {
                var observer = _c.value;
                _loop_1(observer);
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
            }
            finally { if (e_1) throw e_1.error; }
        }
    };
    IntersectionObserverMock.prototype.mock = function () {
        var _this = this;
        if (this.isUsingMockIntersectionObserver) {
            throw new Error('IntersectionObserver is already mocked, but you tried to mock it again.');
        }
        this.isUsingMockIntersectionObserver = true;
        var setObservers = function (setter) {
            return (_this.observers = setter(_this.observers));
        };
        global.IntersectionObserverEntry = /** @class */ (function () {
            function IntersectionObserverEntry() {
            }
            return IntersectionObserverEntry;
        }());
        Object.defineProperty(IntersectionObserverEntry.prototype, 'intersectionRatio', {
            get: function () {
                return 0;
            },
        });
        global.IntersectionObserver = /** @class */ (function () {
            function FakeIntersectionObserver(callback, options) {
                this.callback = callback;
                this.options = options;
            }
            FakeIntersectionObserver.prototype.observe = function (target) {
                var _this = this;
                setObservers(function (observers) { return tslib_1.__spread(observers, [
                    {
                        source: _this,
                        target: target,
                        callback: _this.callback,
                        options: _this.options,
                    },
                ]); });
            };
            FakeIntersectionObserver.prototype.disconnect = function () {
                var _this = this;
                setObservers(function (observers) {
                    return observers.filter(function (observer) { return observer.source !== _this; });
                });
            };
            FakeIntersectionObserver.prototype.unobserve = function (target) {
                var _this = this;
                setObservers(function (observers) {
                    return observers.filter(function (observer) {
                        return !(observer.target === target && observer.source === _this);
                    });
                });
            };
            return FakeIntersectionObserver;
        }());
    };
    IntersectionObserverMock.prototype.restore = function () {
        if (!this.isUsingMockIntersectionObserver) {
            throw new Error('IntersectionObserver is already real, but you tried to restore it again.');
        }
        global.IntersectionObserver = this.originalIntersectionObserver;
        global.IntersectionObserverEntry = this.originalIntersectionObserverEntry;
        this.isUsingMockIntersectionObserver = false;
        this.observers.length = 0;
    };
    IntersectionObserverMock.prototype.isMocked = function () {
        return this.isUsingMockIntersectionObserver;
    };
    IntersectionObserverMock.prototype.ensureMocked = function () {
        if (!this.isUsingMockIntersectionObserver) {
            throw new Error('You must call intersectionObserver.mock() before interacting with the fake IntersectionObserver.');
        }
    };
    return IntersectionObserverMock;
}());
exports.default = IntersectionObserverMock;
function normalizeEntry(entry, target) {
    var isIntersecting = entry.isIntersecting == null
        ? Boolean(entry.intersectionRatio)
        : entry.isIntersecting;
    var intersectionRatio = entry.intersectionRatio || (isIntersecting ? 1 : 0);
    return {
        boundingClientRect: entry.boundingClientRect || target.getBoundingClientRect(),
        intersectionRatio: intersectionRatio,
        intersectionRect: entry.intersectionRect || target.getBoundingClientRect(),
        isIntersecting: isIntersecting,
        rootBounds: entry.rootBounds || document.body.getBoundingClientRect(),
        target: target,
        time: entry.time || Date.now(),
    };
}