@oxog/delay/dist/cjs/utils/browser.js

A comprehensive, zero-dependency delay/timeout utility library with advanced timing features

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.nextFrame = nextFrame;
exports.nextFrames = nextFrames;
exports.idle = idle;
exports.waitForDOMReady = waitForDOMReady;
exports.waitForWindowLoad = waitForWindowLoad;
exports.waitForVisibilityChange = waitForVisibilityChange;
exports.createFrameBasedDelay = createFrameBasedDelay;
exports.createIdleDelay = createIdleDelay;
exports.isRequestAnimationFrameAvailable = isRequestAnimationFrameAvailable;
exports.isRequestIdleCallbackAvailable = isRequestIdleCallbackAvailable;
exports.getEnvironmentCapabilities = getEnvironmentCapabilities;
const index_js_1 = require("../types/index.js");
function nextFrame() {
    if (typeof requestAnimationFrame === 'undefined') {
        throw new index_js_1.DelayError('requestAnimationFrame is not available in this environment', index_js_1.DelayErrorCode.UNSUPPORTED_ENVIRONMENT, { feature: 'requestAnimationFrame' });
    }
    return new Promise((resolve) => {
        requestAnimationFrame(resolve);
    });
}
function nextFrames(count) {
    if (count <= 0) {
        throw new index_js_1.DelayError('Frame count must be positive', index_js_1.DelayErrorCode.INVALID_OPTIONS, { count });
    }
    if (count === 1) {
        return nextFrame();
    }
    return new Promise((resolve) => {
        let remaining = count;
        const tick = (timestamp) => {
            remaining--;
            if (remaining <= 0) {
                resolve(timestamp);
            }
            else {
                requestAnimationFrame(tick);
            }
        };
        requestAnimationFrame(tick);
    });
}
function idle(options = {}) {
    if (typeof requestIdleCallback === 'undefined') {
        // Fallback for environments without requestIdleCallback
        return new Promise((resolve) => {
            setTimeout(() => {
                resolve({
                    didTimeout: false,
                    timeRemaining() {
                        return 50; // Assume 50ms remaining
                    },
                });
            }, 0);
        });
    }
    return new Promise((resolve, reject) => {
        const id = requestIdleCallback(resolve, options);
        // Optional timeout handling
        if (options.timeout) {
            setTimeout(() => {
                if (typeof cancelIdleCallback !== 'undefined') {
                    cancelIdleCallback(id);
                }
                reject(new index_js_1.DelayError(`Idle callback timed out after ${options.timeout}ms`, index_js_1.DelayErrorCode.TIMEOUT, { timeout: options.timeout }));
            }, options.timeout);
        }
    });
}
function waitForDOMReady() {
    if (typeof document === 'undefined') {
        throw new index_js_1.DelayError('DOM is not available in this environment', index_js_1.DelayErrorCode.UNSUPPORTED_ENVIRONMENT, { feature: 'document' });
    }
    if (document.readyState === 'complete' || document.readyState === 'interactive') {
        return Promise.resolve();
    }
    return new Promise((resolve) => {
        const handler = () => {
            document.removeEventListener('DOMContentLoaded', handler);
            resolve();
        };
        document.addEventListener('DOMContentLoaded', handler);
    });
}
function waitForWindowLoad() {
    if (typeof window === 'undefined') {
        throw new index_js_1.DelayError('Window is not available in this environment', index_js_1.DelayErrorCode.UNSUPPORTED_ENVIRONMENT, { feature: 'window' });
    }
    if (document.readyState === 'complete') {
        return Promise.resolve();
    }
    return new Promise((resolve) => {
        const handler = () => {
            window.removeEventListener('load', handler);
            resolve();
        };
        window.addEventListener('load', handler);
    });
}
function waitForVisibilityChange(visible) {
    if (typeof document === 'undefined') {
        throw new index_js_1.DelayError('Document is not available in this environment', index_js_1.DelayErrorCode.UNSUPPORTED_ENVIRONMENT, { feature: 'document' });
    }
    // Check current state
    const isCurrentlyVisible = !document.hidden;
    if (isCurrentlyVisible === visible) {
        return Promise.resolve();
    }
    return new Promise((resolve) => {
        const handler = () => {
            const isVisible = !document.hidden;
            if (isVisible === visible) {
                document.removeEventListener('visibilitychange', handler);
                resolve();
            }
        };
        document.addEventListener('visibilitychange', handler);
    });
}
function createFrameBasedDelay(frames) {
    return nextFrames(frames);
}
function createIdleDelay(maxWait = 5000) {
    return idle({ timeout: maxWait });
}
function isRequestAnimationFrameAvailable() {
    return typeof requestAnimationFrame !== 'undefined';
}
function isRequestIdleCallbackAvailable() {
    return typeof requestIdleCallback !== 'undefined';
}
function getEnvironmentCapabilities() {
    return {
        hasRequestAnimationFrame: isRequestAnimationFrameAvailable(),
        hasRequestIdleCallback: isRequestIdleCallbackAvailable(),
        hasPerformanceNow: typeof performance !== 'undefined' && !!performance.now,
        hasDocument: typeof document !== 'undefined',
        hasWindow: typeof window !== 'undefined',
    };
}
//# sourceMappingURL=browser.js.map