@oscarpalmer/timer 0.28.0 → 0.30.0

package/dist/constants.cjs

@@ -1,7 +1,27 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+'use strict';
+
+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);
+    }
+    last = now;
+    requestAnimationFrame(stepper);
+  }
+}
 const activeTimers = /* @__PURE__ */ new Set();
 const beginTypes = /* @__PURE__ */ new Set(["continue", "start"]);
+const destroyedMessage = "Timer has already been destroyed";
 const endTypes = /* @__PURE__ */ new Set(["pause", "stop"]);
 const endOrRestartTypes = /* @__PURE__ */ new Set([
   "pause",
@@ -9,10 +29,18 @@ const endOrRestartTypes = /* @__PURE__ */ new Set([
   "stop"
 ]);
 const hiddenTimers = /* @__PURE__ */ new Set();
-const milliseconds = 1e3 / 60;
+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.activeTimers = activeTimers;
 exports.beginTypes = beginTypes;
+exports.destroyedMessage = destroyedMessage;
 exports.endOrRestartTypes = endOrRestartTypes;
 exports.endTypes = endTypes;
 exports.hiddenTimers = hiddenTimers;
-exports.milliseconds = milliseconds;
+exports.pauseTypes = pauseTypes;
+exports.startedMessage = startedMessage;

package/dist/constants.js

@@ -1,5 +1,23 @@
+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);
+    }
+    last = now;
+    requestAnimationFrame(stepper);
+  }
+}
 const activeTimers = /* @__PURE__ */ new Set();
 const beginTypes = /* @__PURE__ */ new Set(["continue", "start"]);
+const destroyedMessage = "Timer has already been destroyed";
 const endTypes = /* @__PURE__ */ new Set(["pause", "stop"]);
 const endOrRestartTypes = /* @__PURE__ */ new Set([
   "pause",
@@ -7,12 +25,11 @@ const endOrRestartTypes = /* @__PURE__ */ new Set([
   "stop"
 ]);
 const hiddenTimers = /* @__PURE__ */ new Set();
-const milliseconds = 1e3 / 60;
-export {
-  activeTimers,
-  beginTypes,
-  endOrRestartTypes,
-  endTypes,
-  hiddenTimers,
-  milliseconds
-};
+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);
+
+export { activeTimers, beginTypes, destroyedMessage, endOrRestartTypes, endTypes, hiddenTimers, milliseconds, pauseTypes, startedMessage };

package/dist/delay.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const constants = require('./constants.cjs');
+const get = require('./get.cjs');
+
+function delay(time) {
+  return new Promise((resolve) => {
+    const interval = get.getValidNumber(time, constants.milliseconds);
+    let start;
+    function step(now) {
+      start ??= now;
+      if (interval === constants.milliseconds || now - start >= interval - 5) {
+        resolve();
+      } else {
+        requestAnimationFrame(step);
+      }
+    }
+    requestAnimationFrame(step);
+  });
+}
+
+exports.delay = delay;

package/dist/delay.js

@@ -0,0 +1,20 @@
+import { milliseconds } from './constants.js';
+import { getValidNumber } from './get.js';
+
+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);
+  });
+}
+
+export { delay };

package/dist/get.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const _function = require('./node_modules/@oscarpalmer/atoms/dist/function.cjs');
+
+function getCallback(value) {
+  return typeof value === "function" ? value : _function.noop;
+}
+function getValidNumber(value, defaultValue) {
+  return typeof value === "number" && value > (defaultValue ?? 0) ? value : defaultValue ?? 0;
+}
+
+exports.getCallback = getCallback;
+exports.getValidNumber = getValidNumber;

package/dist/get.js

@@ -0,0 +1,10 @@
+import { noop } from './node_modules/@oscarpalmer/atoms/dist/function.js';
+
+function getCallback(value) {
+  return typeof value === "function" ? value : noop;
+}
+function getValidNumber(value, defaultValue) {
+  return typeof value === "number" && value > (defaultValue ?? 0) ? value : defaultValue ?? 0;
+}
+
+export { getCallback, getValidNumber };

package/dist/global.cjs

@@ -1,5 +1,7 @@
-"use strict";
-const constants = require("./constants.cjs");
+'use strict';
+
+const constants = require('./constants.cjs');
+
 if (globalThis._oscarpalmer_timers == null) {
   Object.defineProperty(globalThis, "_oscarpalmer_timers", {
     get() {
@@ -7,3 +9,16 @@ if (globalThis._oscarpalmer_timers == null) {
     }
   });
 }
+document.addEventListener("visibilitychange", () => {
+  if (document.hidden) {
+    for (const timer of constants.activeTimers) {
+      constants.hiddenTimers.add(timer);
+      timer.pause();
+    }
+  } else {
+    for (const timer of constants.hiddenTimers) {
+      timer.continue();
+    }
+    constants.hiddenTimers.clear();
+  }
+});

package/dist/global.js

@@ -1,4 +1,5 @@
-import { activeTimers } from "./constants.js";
+import { activeTimers, hiddenTimers } from './constants.js';
+
 if (globalThis._oscarpalmer_timers == null) {
   Object.defineProperty(globalThis, "_oscarpalmer_timers", {
     get() {
@@ -6,3 +7,16 @@ 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();
+  }
+});

package/dist/index.cjs

@@ -1,49 +1,21 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const _function = require("@oscarpalmer/atoms/function");
-const constants = require("./constants.cjs");
-require("./global.cjs");
-const timer = require("./timer.cjs");
-const is = require("./is.cjs");
-const when = require("./when.cjs");
-function delay(time, timeout) {
-  return new Promise((resolve, reject) => {
-    let delayed = timer.wait(
-      () => {
-        delayed == null ? void 0 : delayed.destroy();
-        delayed = null;
-        (resolve ?? _function.noop)();
-      },
-      {
-        timeout,
-        errorCallback: () => {
-          delayed == null ? void 0 : delayed.destroy();
-          delayed = null;
-          (reject ?? _function.noop)();
-        },
-        interval: time
-      }
-    );
-  });
-}
-document.addEventListener("visibilitychange", () => {
-  if (document.hidden) {
-    for (const timer2 of constants.activeTimers) {
-      constants.hiddenTimers.add(timer2);
-      timer2.pause();
-    }
-  } else {
-    for (const timer2 of constants.hiddenTimers) {
-      timer2.continue();
-    }
-    constants.hiddenTimers.clear();
-  }
-});
-exports.repeat = timer.repeat;
-exports.wait = timer.wait;
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+require('./global.cjs');
+const delay = require('./delay.cjs');
+const is = require('./is.cjs');
+const repeat = require('./repeat.cjs');
+const wait = require('./wait.cjs');
+const when = require('./when.cjs');
+
+
+
+exports.delay = delay.delay;
 exports.isRepeated = is.isRepeated;
 exports.isTimer = is.isTimer;
 exports.isWaited = is.isWaited;
 exports.isWhen = is.isWhen;
+exports.repeat = repeat.repeat;
+exports.wait = wait.wait;
 exports.when = when.when;
-exports.delay = delay;

package/dist/index.js

@@ -1,50 +1,6 @@
-import { noop } from "@oscarpalmer/atoms/function";
-import { activeTimers, hiddenTimers } from "./constants.js";
-import "./global.js";
-import { wait } from "./timer.js";
-import { repeat } from "./timer.js";
-import { isRepeated, isTimer, isWaited, isWhen } from "./is.js";
-import { when } from "./when.js";
-function delay(time, timeout) {
-  return new Promise((resolve, reject) => {
-    let delayed = wait(
-      () => {
-        delayed == null ? void 0 : delayed.destroy();
-        delayed = null;
-        (resolve ?? noop)();
-      },
-      {
-        timeout,
-        errorCallback: () => {
-          delayed == null ? void 0 : delayed.destroy();
-          delayed = null;
-          (reject ?? noop)();
-        },
-        interval: time
-      }
-    );
-  });
-}
-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();
-  }
-});
-export {
-  delay,
-  isRepeated,
-  isTimer,
-  isWaited,
-  isWhen,
-  repeat,
-  wait,
-  when
-};
+import './global.js';
+export { delay } from './delay.js';
+export { isRepeated, isTimer, isWaited, isWhen } from './is.js';
+export { repeat } from './repeat.js';
+export { wait } from './wait.js';
+export { when } from './when.js';

package/dist/is.cjs

@@ -1,20 +1,23 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function is(pattern, value) {
-  return pattern.test(value == null ? void 0 : value.$timer);
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function is(names, value) {
+  return names.includes(value?.$timer);
 }
 function isRepeated(value) {
-  return is(/^repeat$/, value);
+  return is(["repeat"], value);
 }
 function isTimer(value) {
-  return is(/^repeat|wait$/, value);
+  return is(["repeat", "wait"], value);
 }
 function isWaited(value) {
-  return is(/^wait$/, value);
+  return is(["wait"], value);
 }
 function isWhen(value) {
-  return is(/^when$/, value) && typeof value.then === "function";
+  return is(["when"], value) && typeof value.then === "function";
 }
+
 exports.isRepeated = isRepeated;
 exports.isTimer = isTimer;
 exports.isWaited = isWaited;

package/dist/is.js

@@ -1,21 +1,17 @@
-function is(pattern, value) {
-  return pattern.test(value == null ? void 0 : value.$timer);
+function is(names, value) {
+  return names.includes(value?.$timer);
 }
 function isRepeated(value) {
-  return is(/^repeat$/, value);
+  return is(["repeat"], value);
 }
 function isTimer(value) {
-  return is(/^repeat|wait$/, value);
+  return is(["repeat", "wait"], value);
 }
 function isWaited(value) {
-  return is(/^wait$/, value);
+  return is(["wait"], value);
 }
 function isWhen(value) {
-  return is(/^when$/, value) && typeof value.then === "function";
+  return is(["when"], value) && typeof value.then === "function";
 }
-export {
-  isRepeated,
-  isTimer,
-  isWaited,
-  isWhen
-};
+
+export { isRepeated, isTimer, isWaited, isWhen };

package/dist/models.cjs

@@ -1,9 +1,12 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
 class TimerTrace extends Error {
   constructor() {
     super();
     this.name = "TimerTrace";
   }
 }
+
 exports.TimerTrace = TimerTrace;

package/dist/models.js

@@ -4,6 +4,5 @@ class TimerTrace extends Error {
     this.name = "TimerTrace";
   }
 }
-export {
-  TimerTrace
-};
+
+export { TimerTrace };

package/dist/node_modules/@oscarpalmer/atoms/dist/function.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function noop() {
+}
+
+exports.noop = noop;

package/dist/node_modules/@oscarpalmer/atoms/dist/function.js

@@ -0,0 +1,4 @@
+function noop() {
+}
+
+export { noop };

package/dist/repeat.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 repeat(callback, options) {
+  return new timer.Timer(
+    "repeat",
+    work.work,
+    {
+      callback: get.getCallback(callback),
+      trace: new models.TimerTrace().stack
+    },
+    {
+      onAfter: get.getCallback(options?.onAfter),
+      onError: void 0,
+      count: get.getValidNumber(options?.count),
+      interval: get.getValidNumber(options?.interval, constants.milliseconds),
+      timeout: 0
+    },
+    true
+  );
+}
+
+exports.repeat = repeat;

package/dist/repeat.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 repeat(callback, options) {
+  return new Timer(
+    "repeat",
+    work,
+    {
+      callback: getCallback(callback),
+      trace: new TimerTrace().stack
+    },
+    {
+      onAfter: getCallback(options?.onAfter),
+      onError: void 0,
+      count: getValidNumber(options?.count),
+      interval: getValidNumber(options?.interval, milliseconds),
+      timeout: 0
+    },
+    true
+  );
+}
+
+export { repeat };

package/dist/timer.cjs

@@ -1,111 +1,99 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const constants = require("./constants.cjs");
-const functions = require("./functions.cjs");
-const models = require("./models.cjs");
-class BasicTimer {
-  constructor(type, state) {
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+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 functions.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 functions.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 functions.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 functions.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 functions.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 = functions.getOptions(partial, isRepeated);
-  const instance = new Timer(
-    type,
-    {
-      callback,
-      isRepeated,
-      active: false,
-      destroyed: false,
-      minimum: options.interval - options.interval % constants.milliseconds / 2,
-      paused: false,
-      trace: new models.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
-  );
 }
-exports.BasicTimer = BasicTimer;
+
 exports.Timer = Timer;
-exports.repeat = repeat;
-exports.timer = timer;
-exports.wait = wait;