@oscarpalmer/timer 0.25.0 → 0.26.0

package/dist/index.js

@@ -1,342 +1,48 @@
-// node_modules/@oscarpalmer/atoms/dist/js/function.mjs
-function noop() {
-}
-
-// src/constants.ts
-var activeTimers = new Set;
-var beginTypes = new Set(["continue", "start"]);
-var endTypes = new Set(["pause", "stop"]);
-var endOrRestartTypes = new Set([
-  "pause",
-  "restart",
-  "stop"
-]);
-var hiddenTimers = new Set;
-var milliseconds = 1000 / 60;
-
-// src/global.ts
-if (globalThis._oscarpalmer_timers == null) {
-  Object.defineProperty(globalThis, "_oscarpalmer_timers", {
-    get() {
-      return globalThis._oscarpalmer_timer_debug ? [...activeTimers] : [];
-    }
-  });
-}
-
-// src/functions.ts
-function getOptions(options, isRepeated) {
-  return {
-    afterCallback: options.afterCallback,
-    count: getValueOrDefault(options.count, isRepeated ? Number.POSITIVE_INFINITY : 1),
-    errorCallback: options.errorCallback,
-    interval: getValueOrDefault(options.interval, milliseconds, milliseconds),
-    timeout: getValueOrDefault(options.timeout, isRepeated ? Number.POSITIVE_INFINITY : 30000)
-  };
-}
-function getValueOrDefault(value, defaultValue, minimum) {
-  return typeof value === "number" && value > (minimum ?? 0) ? value : defaultValue;
-}
-function work(type, timer, state, options) {
-  if (state.destroyed && type !== "stop" || beginTypes.has(type) && state.active || endTypes.has(type) && !state.active) {
-    return timer;
-  }
-  const { count, interval, timeout } = options;
-  const { isRepeated, minimum } = state;
-  if (endOrRestartTypes.has(type)) {
-    const isStop = type === "stop";
-    activeTimers.delete(timer);
-    cancelAnimationFrame(state.frame);
-    if (isStop) {
-      options.afterCallback?.(false);
-    }
-    state.active = false;
-    state.frame = undefined;
-    state.paused = !isStop;
-    if (isStop) {
-      state.elapsed = undefined;
-      state.index = undefined;
-    }
-    return type === "restart" ? work("start", timer, state, options) : timer;
-  }
-  state.active = true;
-  state.paused = false;
-  const elapsed = type === "continue" ? +(state.elapsed ?? 0) : 0;
-  let index = type === "continue" ? +(state.index ?? 0) : 0;
-  state.elapsed = elapsed;
-  state.index = index;
-  const total = (count === Number.POSITIVE_INFINITY ? Number.POSITIVE_INFINITY : (count - index) * (interval > 0 ? interval : milliseconds)) - elapsed;
-  let current;
-  let start;
-  function finish(finished, error) {
-    activeTimers.delete(timer);
-    state.active = false;
-    state.elapsed = undefined;
-    state.frame = undefined;
-    state.index = undefined;
-    if (error) {
-      options.errorCallback?.();
-    }
-    options.afterCallback?.(finished);
-  }
-  function step(timestamp) {
-    if (!state.active) {
-      return;
-    }
-    current ??= timestamp;
-    start ??= timestamp;
-    const time = timestamp - current;
-    state.elapsed = elapsed + (current - start);
-    const finished = time - elapsed >= total;
-    if (timestamp - start >= timeout - elapsed) {
-      finish(finished, !finished);
-      return;
-    }
-    if (finished || time >= minimum) {
-      if (state.active) {
-        state.callback(isRepeated ? index : undefined);
-      }
-      index += 1;
-      state.index = index;
-      if (!finished && index < count) {
-        current = null;
-      } else {
-        finish(true, false);
-        return;
-      }
-    }
-    state.frame = requestAnimationFrame(step);
-  }
-  activeTimers.add(timer);
-  state.frame = requestAnimationFrame(step);
-  return timer;
-}
-
-// src/models.ts
-class TimerTrace extends Error {
-  constructor() {
-    super();
-    this.name = "TimerTrace";
-  }
-}
-
-// src/timer.ts
-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
-  }, options);
-  if (start) {
-    instance.start();
-  }
-  return instance;
-}
-function wait(callback, options) {
-  return timer("wait", callback, options == null || typeof options === "number" ? {
-    interval: options
-  } : options, true);
-}
-
-class BasicTimer {
-  constructor(type, state) {
-    this.$timer = type;
-    this.state = state;
-  }
-}
-
-class Timer extends BasicTimer {
-  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 ? this.state.trace : undefined;
-  }
-  constructor(type, state, options) {
-    super(type, state);
-    this.options = options;
-  }
-  continue() {
-    return work("continue", this, this.state, this.options);
-  }
-  destroy() {
-    if (!this.state.destroyed) {
-      this.state.destroyed = true;
-      this.stop();
-      this.options.afterCallback = undefined;
-      this.options.errorCallback = undefined;
-      this.state.callback = undefined;
-      this.state.trace = undefined;
-    }
-  }
-  pause() {
-    return work("pause", this, this.state, this.options);
-  }
-  restart() {
-    return work("restart", this, this.state, this.options);
-  }
-  start() {
-    return work("start", this, this.state, this.options);
-  }
-  stop() {
-    return work("stop", this, this.state, this.options);
-  }
-}
-
-// src/index.ts
+import { activeTimers, hiddenTimers } from "./constants.js";
+import "./global.js";
+import { noop } from "@oscarpalmer/atoms/function";
+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) => {
-    const delayed = wait(() => {
-      delayed.destroy();
-      (resolve ?? noop)();
-    }, {
-      timeout,
-      errorCallback: () => {
+    const delayed = wait(
+      () => {
         delayed.destroy();
-        (reject ?? noop)();
+        (resolve ?? noop)();
       },
-      interval: time
-    });
-  });
-}
-
-// src/is.ts
-function is(pattern, value) {
-  return pattern.test(value?.$timer);
-}
-function isRepeated(value) {
-  return is(/^repeat$/, value);
-}
-function isTimer(value) {
-  return is(/^repeat|wait$/, value);
-}
-function isWaited(value) {
-  return is(/^wait$/, value);
-}
-function isWhen(value) {
-  return is(/^when$/, value) && typeof value.then === "function";
-}
-// src/when.ts
-function when(condition, options) {
-  let result = false;
-  const state = {
-    started: false,
-    timer: timer("repeat", () => {
-      if (condition()) {
-        result = true;
-        state.timer.stop();
+      {
+        timeout,
+        errorCallback: () => {
+          delayed.destroy();
+          (reject ?? noop)();
+        },
+        interval: time
       }
-    }, {
-      afterCallback() {
-        if (!state.timer.paused) {
-          if (result) {
-            state.resolver?.();
-          } else {
-            state.rejecter?.();
-          }
-          instance.destroy();
-        }
-      },
-      errorCallback() {
-        state.rejecter?.();
-        instance.destroy();
-      },
-      count: options?.count,
-      interval: options?.interval,
-      timeout: 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;
 }
-var destroyedMessage = "Timer has already been destroyed";
-var startedMessage = "Timer has already been started";
-
-class When extends BasicTimer {
-  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 this.state.timer?.trace;
-  }
-  constructor(state) {
-    super("when", state);
-  }
-  continue() {
-    this.state.timer?.continue();
-    return this;
-  }
-  destroy() {
-    this.state.timer?.destroy();
-    this.state.promise = undefined;
-    this.state.resolver = noop;
-    this.state.rejecter = noop;
-    this.state.timer = undefined;
-  }
-  pause() {
-    this.state.timer?.pause();
-    return this;
-  }
-  stop() {
-    this.state.timer?.stop();
-    return this;
-  }
-  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);
-  }
-}
-
-// src/index.ts
 document.addEventListener("visibilitychange", () => {
   if (document.hidden) {
-    for (const timer2 of activeTimers) {
-      hiddenTimers.add(timer2);
-      timer2.pause();
+    for (const timer of activeTimers) {
+      hiddenTimers.add(timer);
+      timer.pause();
     }
   } else {
-    for (const timer2 of hiddenTimers) {
-      timer2.continue();
+    for (const timer of hiddenTimers) {
+      timer.continue();
     }
     hiddenTimers.clear();
   }
 });
 export {
-  when,
-  wait,
-  repeat,
-  isWhen,
-  isWaited,
-  isTimer,
+  delay,
   isRepeated,
-  delay
+  isTimer,
+  isWaited,
+  isWhen,
+  repeat,
+  wait,
+  when
 };

package/dist/{is.mjs → is.cjs}

@@ -1,6 +1,7 @@
-// src/is.ts
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 function is(pattern, value) {
-  return pattern.test(value?.$timer);
+  return pattern.test(value == null ? void 0 : value.$timer);
 }
 function isRepeated(value) {
   return is(/^repeat$/, value);
@@ -14,9 +15,7 @@ function isWaited(value) {
 function isWhen(value) {
   return is(/^when$/, value) && typeof value.then === "function";
 }
-export {
-  isWhen,
-  isWaited,
-  isTimer,
-  isRepeated
-};
+exports.isRepeated = isRepeated;
+exports.isTimer = isTimer;
+exports.isWaited = isWaited;
+exports.isWhen = isWhen;

package/dist/is.js

@@ -1,6 +1,5 @@
-// src/is.ts
 function is(pattern, value) {
-  return pattern.test(value?.$timer);
+  return pattern.test(value == null ? void 0 : value.$timer);
 }
 function isRepeated(value) {
   return is(/^repeat$/, value);
@@ -15,8 +14,8 @@ function isWhen(value) {
   return is(/^when$/, value) && typeof value.then === "function";
 }
 export {
-  isWhen,
-  isWaited,
+  isRepeated,
   isTimer,
-  isRepeated
+  isWaited,
+  isWhen
 };

package/dist/models.cjs

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

package/dist/{models.mjs → models.js}

@@ -1,4 +1,3 @@
-// src/models.ts
 class TimerTrace extends Error {
   constructor() {
     super();

package/dist/timer.cjs

@@ -0,0 +1,111 @@
+"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) {
+    this.$timer = type;
+    this.state = state;
+  }
+}
+class Timer extends BasicTimer {
+  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 ? this.state.trace : void 0;
+  }
+  constructor(type, state, options) {
+    super(type, state);
+    this.options = options;
+  }
+  /**
+   * Continues the timer _(if it was paused)_
+   */
+  continue() {
+    return functions.work("continue", this, this.state, this.options);
+  }
+  /**
+   * Destroys the timer _(after stopping it, if it was running)_
+   */
+  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;
+    }
+  }
+  /**
+   * Pauses the timer _(if it was running)_
+   */
+  pause() {
+    return functions.work("pause", this, this.state, this.options);
+  }
+  /**
+   * Restarts the timer _(if it was running)_
+   */
+  restart() {
+    return functions.work("restart", this, this.state, this.options);
+  }
+  /**
+   * Starts the timer _(if it was stopped)_
+   */
+  start() {
+    return functions.work("start", this, this.state, this.options);
+  }
+  /**
+   * Stops the timer _(if it was running)_
+   */
+  stop() {
+    return functions.work("stop", this, this.state, this.options);
+  }
+}
+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()
+    },
+    options
+  );
+  if (start) {
+    instance.start();
+  }
+  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;