@oscarpalmer/timer 0.31.0 → 0.33.0

package/dist/constants.cjs

@@ -2,25 +2,28 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-function stepper(now) {
-  if (values.length === 7) {
-    exports.milliseconds = Math.floor(
-      values.slice(2).reduce((first, second) => first + second) / 5 * 2
-    ) / 2;
-    last = void 0;
-    values.length = 0;
-  } else {
-    last ??= now;
-    const difference = now - last;
-    if (difference > 0) {
-      values.push(difference);
+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);
+      }
     }
-    last = now;
-    requestAnimationFrame(stepper);
-  }
+    requestAnimationFrame(step);
+  });
 }
 const activeTimers = /* @__PURE__ */ new Set();
 const beginTypes = /* @__PURE__ */ new Set(["continue", "start"]);
+const intervalBuffer = 5;
 const destroyedMessage = "Timer has already been destroyed";
 const endTypes = /* @__PURE__ */ new Set(["pause", "stop"]);
 const endOrRestartTypes = /* @__PURE__ */ new Set([
@@ -31,10 +34,10 @@ const endOrRestartTypes = /* @__PURE__ */ new Set([
 const hiddenTimers = /* @__PURE__ */ new Set();
 const pauseTypes = /* @__PURE__ */ new Set(["continue", "pause"]);
 const startedMessage = "Timer has already been started";
-const values = [];
-let last;
-exports.milliseconds = Math.floor(1e3 / 60 * 2) / 2;
-requestAnimationFrame(stepper);
+exports.milliseconds = 1e3 / 60;
+calculate().then((value) => {
+  exports.milliseconds = value;
+});
 
 exports.activeTimers = activeTimers;
 exports.beginTypes = beginTypes;
@@ -42,5 +45,6 @@ exports.destroyedMessage = destroyedMessage;
 exports.endOrRestartTypes = endOrRestartTypes;
 exports.endTypes = endTypes;
 exports.hiddenTimers = hiddenTimers;
+exports.intervalBuffer = intervalBuffer;
 exports.pauseTypes = pauseTypes;
 exports.startedMessage = startedMessage;

package/dist/constants.js

@@ -1,22 +1,25 @@
-function stepper(now) {
-  if (values.length === 7) {
-    milliseconds = Math.floor(
-      values.slice(2).reduce((first, second) => first + second) / 5 * 2
-    ) / 2;
-    last = void 0;
-    values.length = 0;
-  } else {
-    last ??= now;
-    const difference = now - last;
-    if (difference > 0) {
-      values.push(difference);
+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);
+      }
     }
-    last = now;
-    requestAnimationFrame(stepper);
-  }
+    requestAnimationFrame(step);
+  });
 }
 const activeTimers = /* @__PURE__ */ new Set();
 const beginTypes = /* @__PURE__ */ new Set(["continue", "start"]);
+const intervalBuffer = 5;
 const destroyedMessage = "Timer has already been destroyed";
 const endTypes = /* @__PURE__ */ new Set(["pause", "stop"]);
 const endOrRestartTypes = /* @__PURE__ */ new Set([
@@ -27,9 +30,9 @@ const endOrRestartTypes = /* @__PURE__ */ new Set([
 const hiddenTimers = /* @__PURE__ */ new Set();
 const pauseTypes = /* @__PURE__ */ new Set(["continue", "pause"]);
 const startedMessage = "Timer has already been started";
-const values = [];
-let last;
-let milliseconds = Math.floor(1e3 / 60 * 2) / 2;
-requestAnimationFrame(stepper);
+let milliseconds = 1e3 / 60;
+calculate().then((value) => {
+  milliseconds = value;
+});
 
-export { activeTimers, beginTypes, destroyedMessage, endOrRestartTypes, endTypes, hiddenTimers, milliseconds, pauseTypes, startedMessage };
+export { activeTimers, beginTypes, destroyedMessage, endOrRestartTypes, endTypes, hiddenTimers, intervalBuffer, milliseconds, pauseTypes, startedMessage };

package/dist/delay.cjs

@@ -11,7 +11,7 @@ function delay(time) {
     let start;
     function step(now) {
       start ??= now;
-      if (interval === constants.milliseconds || now - start >= interval - 5) {
+      if (interval === constants.milliseconds || now - start >= interval - constants.intervalBuffer) {
         resolve();
       } else {
         requestAnimationFrame(step);

package/dist/delay.js

@@ -1,4 +1,4 @@
-import { milliseconds } from './constants.js';
+import { milliseconds, intervalBuffer } from './constants.js';
 import { getValidNumber } from './get.js';
 
 function delay(time) {
@@ -7,7 +7,7 @@ function delay(time) {
     let start;
     function step(now) {
       start ??= now;
-      if (interval === milliseconds || now - start >= interval - 5) {
+      if (interval === milliseconds || now - start >= interval - intervalBuffer) {
         resolve();
       } else {
         requestAnimationFrame(step);

package/dist/repeat.cjs

@@ -4,14 +4,13 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const constants = require('./constants.cjs');
 const get = require('./get.cjs');
+require('./global.cjs');
 const models = require('./models.cjs');
 const timer = require('./timer.cjs');
-const work = require('./work.cjs');
 
 function repeat(callback, options) {
   return new timer.Timer(
     "repeat",
-    work.work,
     {
       callback: get.getCallback(callback),
       trace: new models.TimerTrace().stack

package/dist/repeat.js

@@ -1,13 +1,12 @@
 import { milliseconds } from './constants.js';
 import { getCallback, getValidNumber } from './get.js';
+import './global.js';
 import { TimerTrace } from './models.js';
 import { Timer } from './timer.js';
-import { work } from './work.js';
 
 function repeat(callback, options) {
   return new Timer(
     "repeat",
-    work,
     {
       callback: getCallback(callback),
       trace: new TimerTrace().stack

package/dist/timer.cjs

@@ -3,10 +3,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const _function = require('@oscarpalmer/atoms/function');
+const work = require('./work.cjs');
 
 class Timer {
-  constructor(type, worker, state, options, start) {
-    this.worker = worker;
+  constructor(type, state, options, start) {
     this.options = options;
     this.$timer = type;
     this.state = {
@@ -62,8 +62,17 @@ class Timer {
     this.options.onAfter = _function.noop;
     this.options.onError = _function.noop;
     this.state.callback = _function.noop;
-    this.state.trace = void 0;
-    this.#work("stop");
+    if (!globalThis._oscarpalmer_timer_debug) {
+      this.state.trace = void 0;
+    }
+    work.stop(
+      {
+        instance: this,
+        type: this.$timer
+      },
+      this.state,
+      this.options
+    );
   }
   /**
    * Pause the timer _(if it's running)_
@@ -90,7 +99,7 @@ class Timer {
     return this.#work("stop");
   }
   #work(type) {
-    return this.worker(
+    return work.work(
       type,
       {
         instance: this,

package/dist/timer.full.js

@@ -1,21 +1,26 @@
-/**
- * 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);
+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);
+            }
         }
-        last = now;
-        requestAnimationFrame(stepper);
-    }
+        requestAnimationFrame(step);
+    });
 }
 /**
  * A set of all active timers
@@ -25,6 +30,10 @@ const activeTimers = new Set();
  * A set of types that allow work to begin
  */
 const beginTypes = new Set(['continue', 'start']);
+/**
+ * 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
  */
@@ -51,13 +60,13 @@ const pauseTypes = new Set(['continue', 'pause']);
  */
 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);
+let milliseconds = 1000 / 60;
+calculate().then(value => {
+    milliseconds = value;
+});
 
 if (globalThis._oscarpalmer_timers == null) {
     Object.defineProperty(globalThis, '_oscarpalmer_timers', {
@@ -102,7 +111,8 @@ function delay(time) {
         let start;
         function step(now) {
             start ??= now;
-            if (interval === milliseconds || now - start >= interval - 5) {
+            if (interval === milliseconds ||
+                now - start >= interval - intervalBuffer) {
                 resolve();
             }
             else {
@@ -148,8 +158,92 @@ class TimerTrace extends Error {
     }
 }
 
+function endOrRestart(type, timer, state, options) {
+    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;
+}
+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 ignore(type, state) {
+    return ((state.destroyed && type !== 'stop') ||
+        (state.active ? beginTypes.has(type) : endTypes.has(type)));
+}
+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 = pauseTypes.has(type);
+    state.elapsed = pausable ? state.elapsed : 0;
+    state.index = pausable ? state.index : 0;
+    state.total = pausable ? state.total : 0;
+}
+function stop(timer, state, options) {
+    endOrRestart('stop', timer, state, options);
+}
+function work(type, timer, state, options) {
+    if (ignore(type, state)) {
+        return timer.instance;
+    }
+    setState(type, state);
+    if (endOrRestartTypes.has(type)) {
+        return endOrRestart(type, timer, state, options);
+    }
+    state.active = true;
+    state.paused = false;
+    activeTimers.add(timer.instance);
+    const runner = run(timer, state, options);
+    state.frame = requestAnimationFrame(runner);
+    return timer.instance;
+}
+
 class Timer {
-    worker;
     options;
     state;
     /**
@@ -178,8 +272,7 @@ class Timer {
             ? this.state.trace
             : undefined;
     }
-    constructor(type, worker, state, options, start) {
-        this.worker = worker;
+    constructor(type, state, options, start) {
         this.options = options;
         this.$timer = type;
         this.state = {
@@ -210,8 +303,13 @@ class Timer {
         this.options.onAfter = noop;
         this.options.onError = noop;
         this.state.callback = noop;
-        this.state.trace = undefined;
-        this.#work('stop');
+        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)_
@@ -238,89 +336,18 @@ class Timer {
         return this.#work('stop');
     }
     #work(type) {
-        return this.worker(type, {
+        return work(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, {
+    return new Timer('repeat', {
         callback: getCallback(callback),
         trace: new TimerTrace().stack,
     }, {
@@ -338,7 +365,7 @@ function repeat(callback, options) {
  * @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
  */
 function wait(callback, time) {
-    return new Timer('wait', work, {
+    return new Timer('wait', {
         callback: getCallback(callback),
         trace: new TimerTrace().stack,
     }, {
@@ -352,7 +379,13 @@ function wait(callback, time) {
 
 class When {
     $timer = 'when';
-    state;
+    state = {
+        promise: undefined,
+        rejecter: undefined,
+        resolver: undefined,
+        started: false,
+        timer: undefined,
+    };
     /**
      * Is the timer active?
      */
@@ -379,8 +412,44 @@ class When {
             ? this.state.timer?.trace
             : undefined;
     }
-    constructor(state) {
-        this.state = state;
+    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('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: getValidNumber(options?.timeout),
+        }, false);
     }
     /**
      * Continues the timer _(if it was paused)_
@@ -393,11 +462,12 @@ class When {
      * 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;
+        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)_
@@ -418,59 +488,23 @@ class When {
      */
     // 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);
+        const { state } = this;
+        if (state.timer == null) {
+            throw new Error(destroyedMessage);
         }
-        this.state.started = true;
-        this.state.timer.start();
-        return this.state.promise.then(resolve ?? noop, reject ?? noop);
+        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) {
-    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;
+    return new When(condition, options);
 }
 
 export { delay, isRepeated, isTimer, isWaited, isWhen, repeat, wait, when };