@oscarpalmer/timer 0.37.0 → 0.38.0

package/dist/timer.full.js

@@ -1,532 +0,0 @@
-function calculate$1() {
-    return new Promise(resolve => {
-        const values = [];
-        let last;
-        function step(now) {
-            if (last != null) {
-                values.push(now - last);
-            }
-            last = now;
-            if (values.length >= 10) {
-                const median = values
-                    .sort()
-                    .slice(2, -2)
-                    .reduce((first, second) => first + second, 0) /
-                    (values.length - 4);
-                resolve(median);
-            }
-            else {
-                requestAnimationFrame(step);
-            }
-        }
-        requestAnimationFrame(step);
-    });
-}
-//
-const defaultTimeout = 30_000;
-/**
- * A set of all active timers
- */
-const activeTimers = new Set();
-/**
- * Buffer value to use when evaluating if a specific time is within a certain range
- */
-const intervalBuffer = 5;
-/**
- * Message to show when a when-timer is destroyed
- */
-const destroyedMessage = 'Timer has already been destroyed';
-/**
- * A set of timers that were paused due to the document being hidden
- */
-const hiddenTimers = new Set();
-/**
- * Message to show when a when-timer is started
- */
-const startedMessage = 'Timer has already been started';
-const TYPE_REPEAT = 'repeat';
-const TYPE_WAIT = 'wait';
-const TYPE_WHEN = 'when';
-const WORK_CONTINUE = 'continue';
-const WORK_PAUSE = 'pause';
-const WORK_RESTART = 'restart';
-const WORK_START = 'start';
-const WORK_STOP = 'stop';
-//
-/**
- * A calculated average of the refresh rate of the display _(in milliseconds)_
- */
-let milliseconds = 1000 / 60;
-calculate$1().then(value => {
-    milliseconds = value;
-});
-
-if (globalThis._oscarpalmer_timers == null) {
-    Object.defineProperty(globalThis, '_oscarpalmer_timers', {
-        get() {
-            return globalThis._oscarpalmer_timer_debug ? [...activeTimers] : [];
-        },
-    });
-}
-/* istanbul ignore next */
-document.addEventListener('visibilitychange', () => {
-    const from = document.hidden ? activeTimers : hiddenTimers;
-    const method = document.hidden ? WORK_PAUSE : WORK_CONTINUE;
-    const to = document.hidden ? hiddenTimers : activeTimers;
-    for (const timer of from) {
-        timer[method]();
-        to.add(timer);
-    }
-    from.clear();
-});
-
-function calculate() {
-	return new Promise((resolve) => {
-		const values = [];
-		let last;
-		function step(now) {
-			if (last != null) values.push(now - last);
-			last = now;
-			if (values.length >= 10) {
-				const median = values.sort().slice(2, -2).reduce((first, second) => first + second, 0) / (values.length - 4);
-				resolve(median);
-			} else requestAnimationFrame(step);
-		}
-		requestAnimationFrame(step);
-	});
-}
-function noop() {}
-calculate().then((value) => {
-});
-
-function getCallback(value) {
-    return typeof value === 'function' ? value : noop;
-}
-function getValidTimeout(value) {
-    return typeof value === 'number' && value > 0 ? value : defaultTimeout;
-}
-function getValidNumber(value, defaultValue) {
-    const actualDefault = defaultValue ?? 0;
-    return typeof value === 'number' && value > actualDefault
-        ? value
-        : actualDefault;
-}
-
-/**
- * Create a delayed promise that resolves after a certain amount of time _(in milliseconds; defaults to screen refresh rate)_
- */
-function delay(time) {
-    return new Promise(resolve => {
-        const interval = getValidNumber(time, milliseconds);
-        let start;
-        function step(now) {
-            start ??= now;
-            if (interval === milliseconds ||
-                now - start >= interval - intervalBuffer) {
-                resolve();
-            }
-            else {
-                requestAnimationFrame(step);
-            }
-        }
-        requestAnimationFrame(step);
-    });
-}
-
-function is(names, value) {
-    return names.includes(value?.$timer);
-}
-/**
- * Is the value a repeating timer?
- */
-function isRepeated(value) {
-    return is([TYPE_REPEAT], value);
-}
-/**
- * Is the value a timer?
- */
-function isTimer(value) {
-    return is([TYPE_REPEAT, TYPE_WAIT], value);
-}
-/**
- * Is the value a waiting timer?
- */
-function isWaited(value) {
-    return is([TYPE_WAIT], value);
-}
-/**
- * Is the value a conditional timer?
- */
-function isWhen(value) {
-    return is([TYPE_WHEN], value) && typeof value.then === 'function';
-}
-
-class TimerTrace extends Error {
-    constructor() {
-        super();
-        this.name = 'TimerTrace';
-    }
-}
-
-function finish(timer, state, options, success) {
-    cancelAnimationFrame(state.frame);
-    activeTimers.delete(timer.instance);
-    state.active = false;
-    state.elapsed = 0;
-    state.frame = undefined;
-    if (timer.type === TYPE_WAIT) {
-        state.callback();
-    }
-    else {
-        options.onAfter?.(success);
-    }
-}
-function ignore(type, state) {
-    if (state.destroyed) {
-        return type !== WORK_STOP;
-    }
-    if (state.paused) {
-        return type === WORK_PAUSE || type === WORK_START;
-    }
-    return state.active && type === WORK_START;
-}
-function pause(timer, state) {
-    cancelAnimationFrame(state.frame);
-    state.frame = undefined;
-    return timer.instance;
-}
-function run(timer, state, options) {
-    let last;
-    return function step(now) {
-        if (!state.active) {
-            return;
-        }
-        last ??= now;
-        const difference = now - last;
-        state.elapsed += difference;
-        state.total += difference;
-        last = now;
-        if (options.timeout > 0 && state.total >= options.timeout) {
-            options.onError?.();
-            finish(timer, state, options, false);
-            return;
-        }
-        if (options.interval === milliseconds ||
-            state.elapsed >= options.interval - intervalBuffer) {
-            if (options.count > -1) {
-                state.callback(state.index);
-            }
-            state.elapsed = 0;
-            state.index += 1;
-            if (options.count === -1 ||
-                (options.count > 0 && state.index >= options.count)) {
-                finish(timer, state, options, true);
-                return;
-            }
-        }
-        state.frame = requestAnimationFrame(step);
-    };
-}
-function setState(type, state) {
-    const pausable = type === WORK_CONTINUE || type === WORK_PAUSE;
-    state.elapsed = pausable ? state.elapsed : 0;
-    state.index = pausable ? state.index : 0;
-    state.total = pausable ? state.total : 0;
-}
-function stop(timer, state, options) {
-    cancelAnimationFrame(state.frame);
-    activeTimers.delete(timer.instance);
-    options.onAfter?.(false);
-    state.active = !stop;
-    state.frame = undefined;
-    state.paused = false;
-    return timer.instance;
-}
-function work(type, timer, state, options) {
-    if (ignore(type, state)) {
-        return timer.instance;
-    }
-    setState(type, state);
-    if (type === WORK_STOP) {
-        return stop(timer, state, options);
-    }
-    if (type === WORK_PAUSE || type === WORK_RESTART) {
-        cancelAnimationFrame(state.frame);
-        state.frame = undefined;
-    }
-    state.active = true;
-    state.paused = type === WORK_PAUSE;
-    if (state.paused) {
-        return pause(timer, state);
-    }
-    activeTimers.add(timer.instance);
-    const runner = run(timer, state, options);
-    state.frame = requestAnimationFrame(runner);
-    return timer.instance;
-}
-
-class Timer {
-    options;
-    state;
-    /**
-     * Is the timer active?
-     */
-    get active() {
-        return this.state.active;
-    }
-    /**
-     * Is the timer destroyed?
-     */
-    get destroyed() {
-        return this.state.destroyed;
-    }
-    /**
-     * Is the timer paused?
-     */
-    get paused() {
-        return this.state.paused;
-    }
-    /**
-     * Get the timer's origin _(if debugging is enabled)_
-     */
-    get trace() {
-        return (globalThis._oscarpalmer_timer_debug ?? false)
-            ? this.state.trace
-            : undefined;
-    }
-    constructor(type, state, options, start) {
-        this.options = options;
-        this.$timer = type;
-        this.state = {
-            ...state,
-            active: false,
-            destroyed: false,
-            elapsed: 0,
-            frame: undefined,
-            index: 0,
-            paused: false,
-            total: 0,
-        };
-        if (start) {
-            this.start();
-        }
-    }
-    /**
-     * Continue running the timer _(if it's paused)_
-     */
-    continue() {
-        return this.#work(WORK_CONTINUE);
-    }
-    /**
-     * Destroy the timer
-     */
-    destroy() {
-        this.state.destroyed = true;
-        this.options.onAfter = noop;
-        this.options.onError = noop;
-        this.state.callback = noop;
-        if (!globalThis._oscarpalmer_timer_debug) {
-            this.state.trace = undefined;
-        }
-        stop({
-            instance: this,
-            type: this.$timer,
-        }, this.state, this.options);
-    }
-    /**
-     * Pause the timer _(if it's running)_
-     */
-    pause() {
-        return this.#work(WORK_PAUSE);
-    }
-    /**
-     * Restart the timer _(or start it, if it's not running)_
-     */
-    restart() {
-        return this.#work(WORK_RESTART);
-    }
-    /**
-     * Start the timer _(if it's not running)_
-     */
-    start() {
-        return this.#work(WORK_START);
-    }
-    /**
-     * Stop the timer _(if it's running)_
-     */
-    stop() {
-        return this.#work(WORK_STOP);
-    }
-    #work(type) {
-        return work(type, {
-            instance: this,
-            type: this.$timer,
-        }, this.state, this.options);
-    }
-}
-
-/**
- * Create a repeating timer
- */
-function repeat(callback, options) {
-    return new Timer(TYPE_REPEAT, {
-        callback: getCallback(callback),
-        trace: new TimerTrace().stack,
-    }, {
-        onAfter: getCallback(options?.onAfter),
-        onError: getCallback(options?.onTimeout),
-        count: getValidNumber(options?.count),
-        interval: getValidNumber(options?.interval, milliseconds),
-        timeout: getValidNumber(options?.timeout),
-    }, true);
-}
-
-/**
- * Create a waiting timer
- * @param callback Callback to run when the timer has finished
- * @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
- */
-function wait(callback, time) {
-    return new Timer(TYPE_WAIT, {
-        callback: getCallback(callback),
-        trace: new TimerTrace().stack,
-    }, {
-        onAfter: undefined,
-        onError: undefined,
-        count: -1,
-        interval: getValidNumber(time, milliseconds),
-        timeout: 0,
-    }, true);
-}
-
-class When {
-    $timer = TYPE_WHEN;
-    state = {
-        promise: undefined,
-        rejecter: undefined,
-        resolver: undefined,
-        started: false,
-        timer: undefined,
-    };
-    /**
-     * Is the timer active?
-     */
-    get active() {
-        return this.state.timer?.active ?? false;
-    }
-    /**
-     * Is the timer destroyed?
-     */
-    get destroyed() {
-        return this.state.timer == null;
-    }
-    /**
-     * Is the timer paused?
-     */
-    get paused() {
-        return this.state.timer?.paused ?? false;
-    }
-    /**
-     * Get the timer's origin _(if debugging is enabled)_
-     */
-    get trace() {
-        return (globalThis._oscarpalmer_timer_debug ?? false)
-            ? this.state.timer?.trace
-            : undefined;
-    }
-    constructor(condition, options) {
-        const { state } = this;
-        state.promise = new Promise((resolve, reject) => {
-            state.resolver = resolve;
-            state.rejecter = reject;
-        });
-        let result = false;
-        this.state.timer = new Timer(TYPE_WHEN, {
-            callback() {
-                try {
-                    if (condition()) {
-                        result = true;
-                        state.timer.stop();
-                    }
-                }
-                catch {
-                    state.timer.stop();
-                }
-            },
-            trace: new TimerTrace().stack,
-        }, {
-            onAfter: () => {
-                if (result) {
-                    state.resolver?.();
-                }
-                else {
-                    state.rejecter?.();
-                }
-                this.destroy();
-            },
-            onError: () => {
-                state.rejecter?.();
-                this.destroy();
-            },
-            count: getValidNumber(options?.count),
-            interval: getValidNumber(options?.interval, milliseconds),
-            timeout: getValidTimeout(options?.timeout),
-        }, false);
-    }
-    /**
-     * Continues the timer _(if it was paused)_
-     */
-    continue() {
-        this.state.timer?.continue();
-        return this;
-    }
-    /**
-     * Destroys the timer _(and stops it,if it was running)_
-     */
-    destroy() {
-        const { state } = this;
-        state.timer?.destroy();
-        state.promise = undefined;
-        state.resolver = noop;
-        state.rejecter = noop;
-        state.timer = undefined;
-    }
-    /**
-     * Pauses the timer _(if it was running)_
-     */
-    pause() {
-        this.state.timer?.pause();
-        return this;
-    }
-    /**
-     * Stops the timer _(if it was running)_
-     */
-    stop() {
-        this.state.timer?.stop();
-        return this;
-    }
-    /**
-     * Starts the timer and returns a promise that resolves when the condition is met
-     */
-    // biome-ignore lint/suspicious/noThenProperty: returning a promise-like object, so it's ok ;)
-    then(resolve, reject) {
-        const { state } = this;
-        if (state.timer == null) {
-            throw new Error(destroyedMessage);
-        }
-        if (state.started) {
-            throw new Error(startedMessage);
-        }
-        state.started = true;
-        state.timer.start();
-        return state.promise.then(resolve ?? noop, reject ?? noop);
-    }
-}
-/**
- * Create a conditional timer
- */
-function when(condition, options) {
-    return new When(condition, options);
-}
-
-export { delay, isRepeated, isTimer, isWaited, isWhen, repeat, wait, when };

package/dist/wait.cjs

@@ -1,18 +0,0 @@
-const require_constants = require("./constants.cjs");
-const require_get = require("./get.cjs");
-require("./global.cjs");
-const require_models = require("./models.cjs");
-const require_timer = require("./timer.cjs");
-function wait(callback, time) {
-	return new require_timer.Timer(require_constants.TYPE_WAIT, {
-		callback: require_get.getCallback(callback),
-		trace: new require_models.TimerTrace().stack
-	}, {
-		onAfter: void 0,
-		onError: void 0,
-		count: -1,
-		interval: require_get.getValidNumber(time, require_constants.milliseconds),
-		timeout: 0
-	}, true);
-}
-exports.wait = wait;

package/dist/when.cjs

@@ -1,96 +0,0 @@
-const require_rolldown_runtime = require("./rolldown_runtime.cjs");
-const require_constants = require("./constants.cjs");
-const require_get = require("./get.cjs");
-require("./global.cjs");
-const require_models = require("./models.cjs");
-const require_timer = require("./timer.cjs");
-let __oscarpalmer_atoms_function = require("@oscarpalmer/atoms/function");
-__oscarpalmer_atoms_function = require_rolldown_runtime.__toESM(__oscarpalmer_atoms_function);
-var When = class {
-	$timer = require_constants.TYPE_WHEN;
-	state = {
-		promise: void 0,
-		rejecter: void 0,
-		resolver: void 0,
-		started: false,
-		timer: void 0
-	};
-	get active() {
-		return this.state.timer?.active ?? false;
-	}
-	get destroyed() {
-		return this.state.timer == null;
-	}
-	get paused() {
-		return this.state.timer?.paused ?? false;
-	}
-	get trace() {
-		return globalThis._oscarpalmer_timer_debug ?? false ? this.state.timer?.trace : void 0;
-	}
-	constructor(condition, options) {
-		const { state } = this;
-		state.promise = new Promise((resolve, reject) => {
-			state.resolver = resolve;
-			state.rejecter = reject;
-		});
-		let result = false;
-		this.state.timer = new require_timer.Timer(require_constants.TYPE_WHEN, {
-			callback() {
-				try {
-					if (condition()) {
-						result = true;
-						state.timer.stop();
-					}
-				} catch {
-					state.timer.stop();
-				}
-			},
-			trace: new require_models.TimerTrace().stack
-		}, {
-			onAfter: () => {
-				if (result) state.resolver?.();
-				else state.rejecter?.();
-				this.destroy();
-			},
-			onError: () => {
-				state.rejecter?.();
-				this.destroy();
-			},
-			count: require_get.getValidNumber(options?.count),
-			interval: require_get.getValidNumber(options?.interval, require_constants.milliseconds),
-			timeout: require_get.getValidTimeout(options?.timeout)
-		}, false);
-	}
-	continue() {
-		this.state.timer?.continue();
-		return this;
-	}
-	destroy() {
-		const { state } = this;
-		state.timer?.destroy();
-		state.promise = void 0;
-		state.resolver = __oscarpalmer_atoms_function.noop;
-		state.rejecter = __oscarpalmer_atoms_function.noop;
-		state.timer = void 0;
-	}
-	pause() {
-		this.state.timer?.pause();
-		return this;
-	}
-	stop() {
-		this.state.timer?.stop();
-		return this;
-	}
-	then(resolve, reject) {
-		const { state } = this;
-		if (state.timer == null) throw new Error(require_constants.destroyedMessage);
-		if (state.started) throw new Error(require_constants.startedMessage);
-		state.started = true;
-		state.timer.start();
-		return state.promise.then(resolve ?? __oscarpalmer_atoms_function.noop, reject ?? __oscarpalmer_atoms_function.noop);
-	}
-};
-function when(condition, options) {
-	return new When(condition, options);
-}
-exports.when = when;