@oscarpalmer/timer 0.28.0 → 0.30.0

package/dist/timer.full.js

@@ -0,0 +1,472 @@
+/**
+ * Stepper to calculate the average refresh rate of the display
+ */
+function stepper(now) {
+    if (values.length === 7) {
+        milliseconds = Math.floor((values.slice(2).reduce((first, second) => first + second) / 5) * 2) / 2;
+        last = undefined;
+        values.length = 0;
+    }
+    else {
+        last ??= now;
+        const difference = now - last;
+        if (difference > 0) {
+            values.push(difference);
+        }
+        last = now;
+        requestAnimationFrame(stepper);
+    }
+}
+/**
+ * A set of all active timers
+ */
+const activeTimers = new Set();
+/**
+ * A set of types that allow work to begin
+ */
+const beginTypes = new Set(['continue', 'start']);
+/**
+ * Message to show when a when-timer is destroyed
+ */
+const destroyedMessage = 'Timer has already been destroyed';
+/**
+ * A set of types that allow work to end
+ */
+const endTypes = new Set(['pause', 'stop']);
+/**
+ * A set of types that allow work to end or restart
+ */
+const endOrRestartTypes = new Set([
+    'pause',
+    'restart',
+    'stop',
+]);
+/**
+ * A set of timers that were paused due to the document being hidden
+ */
+const hiddenTimers = new Set();
+const pauseTypes = new Set(['continue', 'pause']);
+/**
+ * Message to show when a when-timer is started
+ */
+const startedMessage = 'Timer has already been started';
+//
+const values = [];
+let last;
+/**
+ * A calculated average of the refresh rate of the display _(in milliseconds)_
+ */
+let milliseconds = Math.floor((1000 / 60) * 2) / 2;
+requestAnimationFrame(stepper);
+
+if (globalThis._oscarpalmer_timers == null) {
+    Object.defineProperty(globalThis, '_oscarpalmer_timers', {
+        get() {
+            return globalThis._oscarpalmer_timer_debug ? [...activeTimers] : [];
+        },
+    });
+}
+document.addEventListener('visibilitychange', () => {
+    if (document.hidden) {
+        for (const timer of activeTimers) {
+            hiddenTimers.add(timer);
+            timer.pause();
+        }
+    }
+    else {
+        for (const timer of hiddenTimers) {
+            timer.continue();
+        }
+        hiddenTimers.clear();
+    }
+});
+
+function noop() {
+}
+
+function getCallback(value) {
+    return typeof value === 'function' ? value : noop;
+}
+function getValidNumber(value, defaultValue) {
+    return typeof value === 'number' && value > (defaultValue ?? 0)
+        ? value
+        : defaultValue ?? 0;
+}
+
+/**
+ * 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 - 5) {
+                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(['repeat'], value);
+}
+/**
+ * Is the value a timer?
+ */
+function isTimer(value) {
+    return is(['repeat', 'wait'], value);
+}
+/**
+ * Is the value a waiting timer?
+ */
+function isWaited(value) {
+    return is(['wait'], value);
+}
+/**
+ * Is the value a conditional timer?
+ */
+function isWhen(value) {
+    return is(['when'], value) && typeof value.then === 'function';
+}
+
+class TimerTrace extends Error {
+    constructor() {
+        super();
+        this.name = 'TimerTrace';
+    }
+}
+
+class Timer {
+    worker;
+    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, worker, state, options, start) {
+        this.worker = worker;
+        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('continue');
+    }
+    /**
+     * Destroy the timer
+     */
+    destroy() {
+        this.state.destroyed = true;
+        this.#work('stop');
+    }
+    /**
+     * Pause the timer _(if it's running)_
+     */
+    pause() {
+        return this.#work('pause');
+    }
+    /**
+     * Restart the timer _(or start it, if it's not running)_
+     */
+    restart() {
+        return this.#work('restart');
+    }
+    /**
+     * Start the timer _(if it's not running)_
+     */
+    start() {
+        return this.#work('start');
+    }
+    /**
+     * Stop the timer _(if it's running)_
+     */
+    stop() {
+        return this.#work('stop');
+    }
+    #work(type) {
+        return this.worker(type, {
+            instance: this,
+            type: this.$timer,
+        }, this.state, this.options);
+    }
+}
+
+function finish(timer, state, options, success) {
+    activeTimers.delete(timer.instance);
+    state.active = false;
+    state.elapsed = 0;
+    state.frame = undefined;
+    if (timer.type === 'wait') {
+        state.callback();
+    }
+    else {
+        options.onAfter?.(success);
+    }
+}
+function work(type, timer, state, options) {
+    if ((state.destroyed && type !== 'stop') ||
+        (state.active ? beginTypes.has(type) : endTypes.has(type))) {
+        return timer.instance;
+    }
+    const pausable = pauseTypes.has(type);
+    state.elapsed = pausable ? state.elapsed : 0;
+    state.index = pausable ? state.index : 0;
+    state.total = pausable ? state.total : 0;
+    if (endOrRestartTypes.has(type)) {
+        activeTimers.delete(timer.instance);
+        cancelAnimationFrame(state.frame);
+        if (type === 'stop') {
+            options.onAfter?.(false);
+        }
+        state.active = false;
+        state.frame = undefined;
+        state.paused = type === 'pause';
+        return type === 'restart'
+            ? work('start', timer, state, options)
+            : timer.instance;
+    }
+    state.active = true;
+    state.paused = false;
+    let start;
+    function step(now) {
+        if (!state.active) {
+            return;
+        }
+        start ??= now;
+        const difference = now - start;
+        state.elapsed += difference;
+        state.total += difference;
+        if (options.timeout > 0 && state.total >= options.timeout) {
+            options.onError?.();
+            finish(timer, state, options, false);
+            return;
+        }
+        if (options.interval === milliseconds ||
+            state.elapsed >= options.interval - 5) {
+            if (options.count > -1) {
+                state.callback(state.index);
+            }
+            start = now;
+            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);
+    }
+    activeTimers.add(timer.instance);
+    state.frame = requestAnimationFrame(step);
+    return timer.instance;
+}
+
+/**
+ * Create a repeating timer
+ */
+function repeat(callback, options) {
+    return new Timer('repeat', work, {
+        callback: getCallback(callback),
+        trace: new TimerTrace().stack,
+    }, {
+        onAfter: getCallback(options?.onAfter),
+        onError: undefined,
+        count: getValidNumber(options?.count),
+        interval: getValidNumber(options?.interval, milliseconds),
+        timeout: 0,
+    }, 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('wait', work, {
+        callback: getCallback(callback),
+        trace: new TimerTrace().stack,
+    }, {
+        onAfter: undefined,
+        onError: undefined,
+        count: -1,
+        interval: getValidNumber(time, milliseconds),
+        timeout: 0,
+    }, true);
+}
+
+class When {
+    $timer = 'when';
+    state;
+    /**
+     * 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(state) {
+        this.state = state;
+    }
+    /**
+     * 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() {
+        this.state.timer?.destroy();
+        this.state.promise = undefined;
+        this.state.resolver = noop;
+        this.state.rejecter = noop;
+        this.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) {
+        if (this.state.timer == null || this.state?.started) {
+            throw new Error(this.state.timer == null ? destroyedMessage : startedMessage);
+        }
+        this.state.started = true;
+        this.state.timer.start();
+        return this.state.promise.then(resolve ?? noop, reject ?? noop);
+    }
+}
+/**
+ * Create a conditional timer
+ */
+function when(condition, options) {
+    let called = false;
+    let result = false;
+    const state = {
+        started: false,
+        timer: new Timer('when', work, {
+            callback() {
+                if (condition()) {
+                    result = true;
+                    state.timer.stop();
+                }
+            },
+            trace: new TimerTrace().stack,
+        }, {
+            onAfter() {
+                if (!(state.timer?.paused ?? false) && !called) {
+                    called = true;
+                    if (result) {
+                        state.resolver?.();
+                    }
+                    else {
+                        state.rejecter?.();
+                    }
+                    instance.destroy();
+                }
+            },
+            onError() {
+                state.rejecter?.();
+                instance.destroy();
+            },
+            count: getValidNumber(options?.count),
+            interval: getValidNumber(options?.interval, milliseconds),
+            timeout: getValidNumber(options?.timeout),
+        }, false),
+    };
+    const promise = new Promise((resolve, reject) => {
+        state.resolver = resolve;
+        state.rejecter = reject;
+    });
+    state.promise = promise;
+    const instance = new When(state);
+    return instance;
+}
+
+export { delay, isRepeated, isTimer, isWaited, isWhen, repeat, wait, when };

package/dist/timer.js

@@ -1,111 +1,95 @@
-import { milliseconds } from "./constants.js";
-import { work, getOptions } from "./functions.js";
-import { TimerTrace } from "./models.js";
-class BasicTimer {
-  constructor(type, state) {
+class Timer {
+  constructor(type, worker, state, options, start) {
+    this.worker = worker;
+    this.options = options;
     this.$timer = type;
-    this.state = state;
+    this.state = {
+      ...state,
+      active: false,
+      destroyed: false,
+      elapsed: 0,
+      frame: void 0,
+      index: 0,
+      paused: false,
+      total: 0
+    };
+    if (start) {
+      this.start();
+    }
   }
-}
-class Timer extends BasicTimer {
+  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 ? this.state.trace : void 0;
-  }
-  constructor(type, state, options) {
-    super(type, state);
-    this.options = options;
+    return globalThis._oscarpalmer_timer_debug ?? false ? this.state.trace : void 0;
   }
   /**
-   * Continues the timer _(if it was paused)_
+   * Continue running the timer _(if it's paused)_
    */
   continue() {
-    return work("continue", this, this.state, this.options);
+    return this.#work("continue");
   }
   /**
-   * Destroys the timer _(after stopping it, if it was running)_
+   * Destroy the timer
    */
   destroy() {
-    if (!this.state.destroyed) {
-      this.state.destroyed = true;
-      this.stop();
-      this.options.afterCallback = void 0;
-      this.options.errorCallback = void 0;
-      this.state.callback = void 0;
-      this.state.trace = void 0;
-    }
+    this.state.destroyed = true;
+    this.#work("stop");
   }
   /**
-   * Pauses the timer _(if it was running)_
+   * Pause the timer _(if it's running)_
    */
   pause() {
-    return work("pause", this, this.state, this.options);
+    return this.#work("pause");
   }
   /**
-   * Restarts the timer _(if it was running)_
+   * Restart the timer _(or start it, if it's not running)_
    */
   restart() {
-    return work("restart", this, this.state, this.options);
+    return this.#work("restart");
   }
   /**
-   * Starts the timer _(if it was stopped)_
+   * Start the timer _(if it's not running)_
    */
   start() {
-    return work("start", this, this.state, this.options);
+    return this.#work("start");
   }
   /**
-   * Stops the timer _(if it was running)_
+   * Stop the timer _(if it's running)_
    */
   stop() {
-    return work("stop", this, this.state, this.options);
+    return this.#work("stop");
   }
-}
-function repeat(callback, options) {
-  return timer("repeat", callback, options ?? {}, true);
-}
-function timer(type, callback, partial, start) {
-  const isRepeated = type === "repeat";
-  const options = getOptions(partial, isRepeated);
-  const instance = new Timer(
-    type,
-    {
-      callback,
-      isRepeated,
-      active: false,
-      destroyed: false,
-      minimum: options.interval - options.interval % milliseconds / 2,
-      paused: false,
-      trace: new TimerTrace().stack
-    },
-    options
-  );
-  if (start) {
-    instance.start();
+  #work(type) {
+    return this.worker(
+      type,
+      {
+        instance: this,
+        type: this.$timer
+      },
+      this.state,
+      this.options
+    );
   }
-  return instance;
-}
-function wait(callback, options) {
-  return timer(
-    "wait",
-    callback,
-    options == null || typeof options === "number" ? {
-      interval: options
-    } : options,
-    true
-  );
 }
-export {
-  BasicTimer,
-  Timer,
-  repeat,
-  timer,
-  wait
-};
+
+export { Timer };

package/dist/wait.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const constants = require('./constants.cjs');
+const get = require('./get.cjs');
+const models = require('./models.cjs');
+const timer = require('./timer.cjs');
+const work = require('./work.cjs');
+
+function wait(callback, time) {
+  return new timer.Timer(
+    "wait",
+    work.work,
+    {
+      callback: get.getCallback(callback),
+      trace: new models.TimerTrace().stack
+    },
+    {
+      onAfter: void 0,
+      onError: void 0,
+      count: -1,
+      interval: get.getValidNumber(time, constants.milliseconds),
+      timeout: 0
+    },
+    true
+  );
+}
+
+exports.wait = wait;

package/dist/wait.js

@@ -0,0 +1,26 @@
+import { milliseconds } from './constants.js';
+import { getCallback, getValidNumber } from './get.js';
+import { TimerTrace } from './models.js';
+import { Timer } from './timer.js';
+import { work } from './work.js';
+
+function wait(callback, time) {
+  return new Timer(
+    "wait",
+    work,
+    {
+      callback: getCallback(callback),
+      trace: new TimerTrace().stack
+    },
+    {
+      onAfter: void 0,
+      onError: void 0,
+      count: -1,
+      interval: getValidNumber(time, milliseconds),
+      timeout: 0
+    },
+    true
+  );
+}
+
+export { wait };