@oscarpalmer/timer 0.32.0 → 0.34.0

package/dist/timer.cjs

@@ -1,114 +1,66 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const _function = require('@oscarpalmer/atoms/function');
-const work = require('./work.cjs');
-
-class Timer {
-  constructor(type, state, options, start) {
-    this.options = options;
-    this.$timer = type;
-    this.state = {
-      ...state,
-      active: false,
-      destroyed: false,
-      elapsed: 0,
-      frame: void 0,
-      index: 0,
-      paused: false,
-      total: 0
-    };
-    if (start) {
-      this.start();
-    }
-  }
-  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 : void 0;
-  }
-  /**
-   * Continue running the timer _(if it's paused)_
-   */
-  continue() {
-    return this.#work("continue");
-  }
-  /**
-   * Destroy the timer
-   */
-  destroy() {
-    this.state.destroyed = true;
-    this.options.onAfter = _function.noop;
-    this.options.onError = _function.noop;
-    this.state.callback = _function.noop;
-    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)_
-   */
-  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 work.work(
-      type,
-      {
-        instance: this,
-        type: this.$timer
-      },
-      this.state,
-      this.options
-    );
-  }
-}
-
+const require_rolldown_runtime = require("./rolldown_runtime.cjs");
+const require_constants = require("./constants.cjs");
+const require_work = require("./work.cjs");
+const __oscarpalmer_atoms_function = require_rolldown_runtime.__toESM(require("@oscarpalmer/atoms/function"));
+var Timer = class {
+	get active() {
+		return this.state.active;
+	}
+	get destroyed() {
+		return this.state.destroyed;
+	}
+	get paused() {
+		return this.state.paused;
+	}
+	get trace() {
+		return globalThis._oscarpalmer_timer_debug ?? false ? this.state.trace : void 0;
+	}
+	constructor(type, state, options, start) {
+		this.options = options;
+		this.$timer = type;
+		this.state = {
+			...state,
+			active: false,
+			destroyed: false,
+			elapsed: 0,
+			frame: void 0,
+			index: 0,
+			paused: false,
+			total: 0
+		};
+		if (start) this.start();
+	}
+	continue() {
+		return this.#work(require_constants.WORK_CONTINUE);
+	}
+	destroy() {
+		this.state.destroyed = true;
+		this.options.onAfter = __oscarpalmer_atoms_function.noop;
+		this.options.onError = __oscarpalmer_atoms_function.noop;
+		this.state.callback = __oscarpalmer_atoms_function.noop;
+		if (!globalThis._oscarpalmer_timer_debug) this.state.trace = void 0;
+		require_work.stop({
+			instance: this,
+			type: this.$timer
+		}, this.state, this.options);
+	}
+	pause() {
+		return this.#work(require_constants.WORK_PAUSE);
+	}
+	restart() {
+		return this.#work(require_constants.WORK_RESTART);
+	}
+	start() {
+		return this.#work(require_constants.WORK_START);
+	}
+	stop() {
+		return this.#work(require_constants.WORK_STOP);
+	}
+	#work(type) {
+		return require_work.work(type, {
+			instance: this,
+			type: this.$timer
+		}, this.state, this.options);
+	}
+};
 exports.Timer = Timer;

package/dist/timer.full.js

@@ -1,4 +1,4 @@
-function calculate() {
+function calculate$1() {
     return new Promise(resolve => {
         const values = [];
         let last;
@@ -26,10 +26,6 @@ function calculate() {
  * 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']);
 /**
  * Buffer value to use when evaluating if a specific time is within a certain range
  */
@@ -38,33 +34,28 @@ const intervalBuffer = 5;
  * 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 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().then(value => {
+calculate$1().then(value => {
     milliseconds = value;
 });
 
@@ -76,22 +67,33 @@ if (globalThis._oscarpalmer_timers == null) {
     });
 }
 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();
+    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 noop() {
+function calculate() {
+	return new Promise((resolve) => {
+		const values = [];
+		let last;
+		function step(now) {
+			if (last != null) values.push(now - last);
+			if (last = now, 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;
@@ -130,25 +132,25 @@ function is(names, value) {
  * Is the value a repeating timer?
  */
 function isRepeated(value) {
-    return is(['repeat'], value);
+    return is([TYPE_REPEAT], value);
 }
 /**
  * Is the value a timer?
  */
 function isTimer(value) {
-    return is(['repeat', 'wait'], value);
+    return is([TYPE_REPEAT, TYPE_WAIT], value);
 }
 /**
  * Is the value a waiting timer?
  */
 function isWaited(value) {
-    return is(['wait'], value);
+    return is([TYPE_WAIT], value);
 }
 /**
  * Is the value a conditional timer?
  */
 function isWhen(value) {
-    return is(['when'], value) && typeof value.then === 'function';
+    return is([TYPE_WHEN], value) && typeof value.then === 'function';
 }
 
 class TimerTrace extends Error {
@@ -158,24 +160,13 @@ 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) {
+    cancelAnimationFrame(state.frame);
     activeTimers.delete(timer.instance);
     state.active = false;
     state.elapsed = 0;
     state.frame = undefined;
-    if (timer.type === 'wait') {
+    if (timer.type === TYPE_WAIT) {
         state.callback();
     }
     else {
@@ -183,19 +174,30 @@ function finish(timer, state, options, success) {
     }
 }
 function ignore(type, state) {
-    return ((state.destroyed && type !== 'stop') ||
-        (state.active ? beginTypes.has(type) : endTypes.has(type)));
+    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 start;
+    let last;
     return function step(now) {
         if (!state.active) {
             return;
         }
-        start ??= now;
-        const difference = now - start;
+        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);
@@ -206,7 +208,6 @@ function run(timer, state, options) {
             if (options.count > -1) {
                 state.callback(state.index);
             }
-            start = now;
             state.elapsed = 0;
             state.index += 1;
             if (options.count === -1 ||
@@ -219,24 +220,37 @@ function run(timer, state, options) {
     };
 }
 function setState(type, state) {
-    const pausable = pauseTypes.has(type);
+    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) {
-    endOrRestart('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 (endOrRestartTypes.has(type)) {
-        return endOrRestart(type, timer, state, options);
+    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 = false;
+    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);
@@ -268,7 +282,7 @@ class Timer {
      * Get the timer's origin _(if debugging is enabled)_
      */
     get trace() {
-        return globalThis._oscarpalmer_timer_debug ?? false
+        return (globalThis._oscarpalmer_timer_debug ?? false)
             ? this.state.trace
             : undefined;
     }
@@ -293,7 +307,7 @@ class Timer {
      * Continue running the timer _(if it's paused)_
      */
     continue() {
-        return this.#work('continue');
+        return this.#work(WORK_CONTINUE);
     }
     /**
      * Destroy the timer
@@ -315,25 +329,25 @@ class Timer {
      * Pause the timer _(if it's running)_
      */
     pause() {
-        return this.#work('pause');
+        return this.#work(WORK_PAUSE);
     }
     /**
      * Restart the timer _(or start it, if it's not running)_
      */
     restart() {
-        return this.#work('restart');
+        return this.#work(WORK_RESTART);
     }
     /**
      * Start the timer _(if it's not running)_
      */
     start() {
-        return this.#work('start');
+        return this.#work(WORK_START);
     }
     /**
      * Stop the timer _(if it's running)_
      */
     stop() {
-        return this.#work('stop');
+        return this.#work(WORK_STOP);
     }
     #work(type) {
         return work(type, {
@@ -347,7 +361,7 @@ class Timer {
  * Create a repeating timer
  */
 function repeat(callback, options) {
-    return new Timer('repeat', {
+    return new Timer(TYPE_REPEAT, {
         callback: getCallback(callback),
         trace: new TimerTrace().stack,
     }, {
@@ -365,7 +379,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', {
+    return new Timer(TYPE_WAIT, {
         callback: getCallback(callback),
         trace: new TimerTrace().stack,
     }, {
@@ -378,7 +392,7 @@ function wait(callback, time) {
 }
 
 class When {
-    $timer = 'when';
+    $timer = TYPE_WHEN;
     state = {
         promise: undefined,
         rejecter: undefined,
@@ -408,7 +422,7 @@ class When {
      * Get the timer's origin _(if debugging is enabled)_
      */
     get trace() {
-        return globalThis._oscarpalmer_timer_debug ?? false
+        return (globalThis._oscarpalmer_timer_debug ?? false)
             ? this.state.timer?.trace
             : undefined;
     }
@@ -419,7 +433,7 @@ class When {
             state.rejecter = reject;
         });
         let result = false;
-        this.state.timer = new Timer('when', {
+        this.state.timer = new Timer(TYPE_WHEN, {
             callback() {
                 try {
                     if (condition()) {

package/dist/timer.js

@@ -1,110 +1,65 @@
-import { noop } from '@oscarpalmer/atoms/function';
-import { stop, work } from './work.js';
-
-class Timer {
-  constructor(type, state, options, start) {
-    this.options = options;
-    this.$timer = type;
-    this.state = {
-      ...state,
-      active: false,
-      destroyed: false,
-      elapsed: 0,
-      frame: void 0,
-      index: 0,
-      paused: false,
-      total: 0
-    };
-    if (start) {
-      this.start();
-    }
-  }
-  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 : void 0;
-  }
-  /**
-   * Continue running the timer _(if it's paused)_
-   */
-  continue() {
-    return this.#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 = void 0;
-    }
-    stop(
-      {
-        instance: this,
-        type: this.$timer
-      },
-      this.state,
-      this.options
-    );
-  }
-  /**
-   * 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 work(
-      type,
-      {
-        instance: this,
-        type: this.$timer
-      },
-      this.state,
-      this.options
-    );
-  }
-}
-
+import { WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP } from "./constants.js";
+import { stop, work } from "./work.js";
+import { noop } from "@oscarpalmer/atoms/function";
+var Timer = class {
+	get active() {
+		return this.state.active;
+	}
+	get destroyed() {
+		return this.state.destroyed;
+	}
+	get paused() {
+		return this.state.paused;
+	}
+	get trace() {
+		return globalThis._oscarpalmer_timer_debug ?? false ? this.state.trace : void 0;
+	}
+	constructor(type, state, options, start) {
+		this.options = options;
+		this.$timer = type;
+		this.state = {
+			...state,
+			active: false,
+			destroyed: false,
+			elapsed: 0,
+			frame: void 0,
+			index: 0,
+			paused: false,
+			total: 0
+		};
+		if (start) this.start();
+	}
+	continue() {
+		return this.#work(WORK_CONTINUE);
+	}
+	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 = void 0;
+		stop({
+			instance: this,
+			type: this.$timer
+		}, this.state, this.options);
+	}
+	pause() {
+		return this.#work(WORK_PAUSE);
+	}
+	restart() {
+		return this.#work(WORK_RESTART);
+	}
+	start() {
+		return this.#work(WORK_START);
+	}
+	stop() {
+		return this.#work(WORK_STOP);
+	}
+	#work(type) {
+		return work(type, {
+			instance: this,
+			type: this.$timer
+		}, this.state, this.options);
+	}
+};
 export { Timer };