@shopify/jest-dom-mocks/dist/request-idle-callback.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = require("tslib");
var RequestIdleCallback = /** @class */ (function () {
    function RequestIdleCallback() {
        var _this = this;
        this.isUsingMockIdleCallback = false;
        this.isMockingUnsupported = false;
        this.queued = {};
        this.currentIdleCallback = 0;
        this.requestIdleCallback = function (callback) {
            _this.currentIdleCallback += 1;
            _this.queued[_this.currentIdleCallback] = callback;
            return _this.currentIdleCallback;
        };
        this.cancelIdleCallback = function (callback) {
            delete _this.queued[callback];
        };
    }
    RequestIdleCallback.prototype.mock = function () {
        if (this.isUsingMockIdleCallback) {
            throw new Error('requestIdleCallback is already mocked, but you tried to mock it again.');
        }
        this.isUsingMockIdleCallback = true;
        var windowWithIdle = window;
        this.originalRequestIdleCallback = windowWithIdle.requestIdleCallback;
        windowWithIdle.requestIdleCallback = this.requestIdleCallback;
        this.originalCancelIdleCallback = windowWithIdle.cancelIdleCallback;
        windowWithIdle.cancelIdleCallback = this.cancelIdleCallback;
    };
    RequestIdleCallback.prototype.mockAsUnsupported = function () {
        if (this.isUsingMockIdleCallback) {
            throw new Error('requestIdleCallback is already mocked, but you tried to mock it again.');
        }
        this.isUsingMockIdleCallback = true;
        this.isMockingUnsupported = true;
        var windowWithIdle = window;
        this.originalRequestIdleCallback = windowWithIdle.requestIdleCallback;
        delete windowWithIdle.requestIdleCallback;
        this.originalCancelIdleCallback = windowWithIdle.cancelIdleCallback;
        delete windowWithIdle.cancelIdleCallback;
    };
    RequestIdleCallback.prototype.restore = function () {
        if (!this.isUsingMockIdleCallback) {
            throw new Error('requestIdleCallback is already real, but you tried to restore it again.');
        }
        if (Object.keys(this.queued).length > 0) {
            // eslint-disable-next-line no-console
            console.warn('You are restoring requestIdleCallback, but some idle callbacks have not been run. You can run requestIdleCallback.cancelIdleCallback() to clear them all and avoid this warning.');
            this.cancelIdleCallbacks();
        }
        this.isUsingMockIdleCallback = false;
        this.isMockingUnsupported = false;
        if (this.originalRequestIdleCallback) {
            window.requestIdleCallback = this.originalRequestIdleCallback;
        }
        else {
            delete window.requestIdleCallback;
        }
        if (this.originalCancelIdleCallback) {
            window.cancelIdleCallback = this.originalCancelIdleCallback;
        }
        else {
            delete window.cancelIdleCallback;
        }
    };
    RequestIdleCallback.prototype.isMocked = function () {
        return this.isUsingMockIdleCallback;
    };
    RequestIdleCallback.prototype.runIdleCallbacks = function (timeRemaining, didTimeout) {
        var _this = this;
        if (timeRemaining === void 0) { timeRemaining = Infinity; }
        if (didTimeout === void 0) { didTimeout = false; }
        this.ensureIdleCallbackIsMock();
        // We need to do it this way so that frames that queue other frames
        // don't get removed
        Object.keys(this.queued).forEach(function (frame) {
            var callback = _this.queued[frame];
            delete _this.queued[frame];
            callback({ timeRemaining: function () { return timeRemaining; }, didTimeout: didTimeout });
        });
    };
    RequestIdleCallback.prototype.cancelIdleCallbacks = function () {
        var e_1, _a;
        this.ensureIdleCallbackIsMock();
        try {
            for (var _b = tslib_1.__values(Object.keys(this.queued)), _c = _b.next(); !_c.done; _c = _b.next()) {
                var id = _c.value;
                this.cancelIdleCallback(id);
            }
        }
        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; }
        }
    };
    RequestIdleCallback.prototype.ensureIdleCallbackIsMock = function () {
        if (!this.isUsingMockIdleCallback) {
            throw new Error('You must call requestIdleCallback.mock() before interacting with the mock request- or cancel- IdleCallback methods.');
        }
        if (this.isMockingUnsupported) {
            throw new Error('You have mocked requestIdleCallback as unsupported. Call requestIdleCallback.restore(), then requestIdleCallback.mock() if you want to simulate idle callbacks.');
        }
    };
    return RequestIdleCallback;
}());
exports.default = RequestIdleCallback;