@oscarpalmer/timer 0.25.0 → 0.26.0

package/dist/timer.js

@@ -1,145 +1,12 @@
-// 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/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);
-}
-
+import { milliseconds } from "./constants.js";
+import { work, getOptions } from "./functions.js";
+import { TimerTrace } from "./models.js";
 class BasicTimer {
   constructor(type, state) {
     this.$timer = type;
     this.state = state;
   }
 }
-
 class Timer extends BasicTimer {
   get active() {
     return this.state.active;
@@ -151,42 +18,94 @@ class Timer extends BasicTimer {
     return this.state.paused;
   }
   get trace() {
-    return globalThis._oscarpalmer_timer_debug ? this.state.trace : undefined;
+    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 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 = undefined;
-      this.options.errorCallback = undefined;
-      this.state.callback = undefined;
-      this.state.trace = undefined;
+      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 work("pause", this, this.state, this.options);
   }
+  /**
+   * Restarts the timer _(if it was running)_
+   */
   restart() {
     return work("restart", this, this.state, this.options);
   }
+  /**
+   * Starts the timer _(if it was stopped)_
+   */
   start() {
     return work("start", this, this.state, this.options);
   }
+  /**
+   * Stops the timer _(if it was running)_
+   */
   stop() {
     return 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 = 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
+  );
+}
 export {
-  wait,
-  timer,
-  repeat,
+  BasicTimer,
   Timer,
-  BasicTimer
+  repeat,
+  timer,
+  wait
 };

package/dist/when.cjs

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _function = require("@oscarpalmer/atoms/function");
+const timer = require("./timer.cjs");
+const destroyedMessage = "Timer has already been destroyed";
+const startedMessage = "Timer has already been started";
+class When extends timer.BasicTimer {
+  get active() {
+    var _a;
+    return ((_a = this.state.timer) == null ? void 0 : _a.active) ?? false;
+  }
+  get destroyed() {
+    return this.state.timer == null;
+  }
+  get paused() {
+    var _a;
+    return ((_a = this.state.timer) == null ? void 0 : _a.paused) ?? false;
+  }
+  get trace() {
+    var _a;
+    return (_a = this.state.timer) == null ? void 0 : _a.trace;
+  }
+  constructor(state) {
+    super("when", state);
+  }
+  /**
+   * Continues the timer _(if it was paused)_
+   */
+  continue() {
+    var _a;
+    (_a = this.state.timer) == null ? void 0 : _a.continue();
+    return this;
+  }
+  /**
+   * Destroys the timer _(and stops it,if it was running)_
+   */
+  destroy() {
+    var _a;
+    (_a = this.state.timer) == null ? void 0 : _a.destroy();
+    this.state.promise = void 0;
+    this.state.resolver = _function.noop;
+    this.state.rejecter = _function.noop;
+    this.state.timer = void 0;
+  }
+  /**
+   * Pauses the timer _(if it was running)_
+   */
+  pause() {
+    var _a;
+    (_a = this.state.timer) == null ? void 0 : _a.pause();
+    return this;
+  }
+  /**
+   * Stops the timer _(if it was running)_
+   */
+  stop() {
+    var _a;
+    (_a = this.state.timer) == null ? void 0 : _a.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) {
+    var _a;
+    if (this.state.timer == null || ((_a = this.state) == null ? void 0 : _a.started)) {
+      throw new Error(
+        this.state.timer == null ? destroyedMessage : startedMessage
+      );
+    }
+    this.state.started = true;
+    this.state.timer.start();
+    return this.state.promise.then(resolve ?? _function.noop, reject ?? _function.noop);
+  }
+}
+function when(condition, options) {
+  let result = false;
+  const state = {
+    started: false,
+    timer: timer.timer(
+      "repeat",
+      () => {
+        if (condition()) {
+          result = true;
+          state.timer.stop();
+        }
+      },
+      {
+        afterCallback() {
+          var _a, _b;
+          if (!state.timer.paused) {
+            if (result) {
+              (_a = state.resolver) == null ? void 0 : _a.call(state);
+            } else {
+              (_b = state.rejecter) == null ? void 0 : _b.call(state);
+            }
+            instance.destroy();
+          }
+        },
+        errorCallback() {
+          var _a;
+          (_a = state.rejecter) == null ? void 0 : _a.call(state);
+          instance.destroy();
+        },
+        count: options == null ? void 0 : options.count,
+        interval: options == null ? void 0 : options.interval,
+        timeout: options == null ? void 0 : 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;
+}
+exports.When = When;
+exports.when = when;