@oscarpalmer/timer 0.21.1 → 0.22.1

package/dist/constants.js

@@ -0,0 +1,9 @@
+// src/constants.ts
+var activeTimers = new Set;
+var hiddenTimers = new Set;
+var milliseconds = 1000 / 60;
+export {
+  milliseconds,
+  hiddenTimers,
+  activeTimers
+};

package/dist/constants.mjs

@@ -0,0 +1,9 @@
+// src/constants.ts
+var activeTimers = new Set;
+var hiddenTimers = new Set;
+var milliseconds = 1000 / 60;
+export {
+  milliseconds,
+  hiddenTimers,
+  activeTimers
+};

package/dist/functions.js

@@ -0,0 +1,97 @@
+// src/constants.ts
+var activeTimers = new Set;
+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 (["continue", "start"].includes(type) && state.active || ["pause", "stop"].includes(type) && !state.active) {
+    return timer;
+  }
+  const { count, interval, timeout } = options;
+  const { isRepeated, minimum } = state;
+  if (["pause", "restart", "stop"].includes(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;
+}
+export {
+  work,
+  getValueOrDefault,
+  getOptions
+};

package/dist/functions.mjs

@@ -0,0 +1,93 @@
+// src/functions.ts
+import {activeTimers, milliseconds} from "./constants";
+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 (["continue", "start"].includes(type) && state.active || ["pause", "stop"].includes(type) && !state.active) {
+    return timer;
+  }
+  const { count, interval, timeout } = options;
+  const { isRepeated, minimum } = state;
+  if (["pause", "restart", "stop"].includes(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;
+}
+export {
+  work,
+  getValueOrDefault,
+  getOptions
+};

package/dist/global.js

@@ -0,0 +1,13 @@
+// src/constants.ts
+var activeTimers = new Set;
+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] : [];
+    }
+  });
+}

package/dist/global.mjs

@@ -0,0 +1,9 @@
+// src/global.ts
+import {activeTimers} from "./constants";
+if (globalThis._oscarpalmer_timers == null) {
+  Object.defineProperty(globalThis, "_oscarpalmer_timers", {
+    get() {
+      return globalThis._oscarpalmer_timer_debug ? [...activeTimers] : [];
+    }
+  });
+}

package/dist/index.js

@@ -0,0 +1,292 @@
+// node_modules/@oscarpalmer/atoms/dist/js/function.mjs
+function noop() {
+}
+
+// src/constants.ts
+var activeTimers = new Set;
+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 (["continue", "start"].includes(type) && state.active || ["pause", "stop"].includes(type) && !state.active) {
+    return timer;
+  }
+  const { count, interval, timeout } = options;
+  const { isRepeated, minimum } = state;
+  if (["pause", "restart", "stop"].includes(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/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,
+    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 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);
+  }
+  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);
+  }
+}
+
+class TimerTrace extends Error {
+  constructor() {
+    super();
+    this.name = "TimerTrace";
+  }
+}
+
+// src/index.ts
+function delay(time, timeout) {
+  return new Promise((resolve, reject) => {
+    wait(resolve ?? noop, {
+      timeout,
+      errorCallback: reject ?? 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) {
+  const repeated = timer("repeat", () => {
+    if (condition()) {
+      repeated.stop();
+      state.resolver?.();
+    }
+  }, {
+    afterCallback() {
+      if (!repeated.paused) {
+        if (condition()) {
+          state.resolver?.();
+        } else {
+          state.rejecter?.();
+        }
+      }
+    },
+    errorCallback() {
+      state.rejecter?.();
+    },
+    count: options?.count,
+    interval: options?.interval,
+    timeout: options?.timeout
+  }, false);
+  const state = {};
+  state.promise = new Promise((resolve, reject) => {
+    state.resolver = resolve;
+    state.rejecter = reject;
+  });
+  state.timer = repeated;
+  return new When(state);
+}
+
+class When extends BasicTimer {
+  get active() {
+    return this.state.timer.active;
+  }
+  get paused() {
+    return this.state.timer.paused;
+  }
+  constructor(state) {
+    super("when", state);
+  }
+  continue() {
+    this.state.timer.continue();
+    return this;
+  }
+  pause() {
+    this.state.timer.pause();
+    return this;
+  }
+  stop() {
+    if (this.state.timer.active) {
+      this.state.timer.stop();
+      this.state.rejecter?.();
+    }
+    return this;
+  }
+  then(resolve, reject) {
+    this.state.timer.start();
+    return this.state.promise.then(resolve ?? noop, reject ?? noop);
+  }
+}
+
+// src/index.ts
+document.addEventListener("visibilitychange", () => {
+  if (document.hidden) {
+    for (const timer4 of activeTimers) {
+      hiddenTimers.add(timer4);
+      timer4.pause();
+    }
+  } else {
+    for (const timer4 of hiddenTimers) {
+      timer4.continue();
+    }
+    hiddenTimers.clear();
+  }
+});
+export {
+  when,
+  wait,
+  repeat,
+  isWhen,
+  isWaited,
+  isTimer,
+  isRepeated,
+  delay
+};

package/dist/index.mjs

@@ -0,0 +1,40 @@
+// src/index.ts
+import {noop} from "@oscarpalmer/atoms/function";
+import {activeTimers, hiddenTimers} from "./constants";
+import"./global";
+import {wait} from "./timer";
+function delay(time, timeout) {
+  return new Promise((resolve, reject) => {
+    wait(resolve ?? noop, {
+      timeout,
+      errorCallback: reject ?? noop,
+      interval: time
+    });
+  });
+}
+import {isRepeated, isTimer, isWaited, isWhen} from "./is";
+import {repeat, wait as wait2} from "./timer";
+import {when} from "./when";
+document.addEventListener("visibilitychange", () => {
+  if (document.hidden) {
+    for (const timer2 of activeTimers) {
+      hiddenTimers.add(timer2);
+      timer2.pause();
+    }
+  } else {
+    for (const timer2 of hiddenTimers) {
+      timer2.continue();
+    }
+    hiddenTimers.clear();
+  }
+});
+export {
+  when,
+  wait2 as wait,
+  repeat,
+  isWhen,
+  isWaited,
+  isTimer,
+  isRepeated,
+  delay
+};

package/dist/is.js

@@ -0,0 +1,22 @@
+// 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";
+}
+export {
+  isWhen,
+  isWaited,
+  isTimer,
+  isRepeated
+};

package/dist/is.mjs

@@ -0,0 +1,22 @@
+// 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";
+}
+export {
+  isWhen,
+  isWaited,
+  isTimer,
+  isRepeated
+};

package/dist/timer.js

@@ -1,21 +1,8 @@
-// node_modules/@oscarpalmer/atoms/dist/js/function.mjs
-function noop() {
-}
-
 // src/constants.ts
 var activeTimers = new Set;
 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 {
@@ -174,119 +161,10 @@ class TimerTrace extends Error {
     this.name = "TimerTrace";
   }
 }
-
-// src/index.ts
-function delay(time, timeout) {
-  return new Promise((resolve, reject) => {
-    wait(resolve ?? noop, {
-      timeout,
-      errorCallback: reject ?? 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) {
-  const repeated = timer("repeat", () => {
-    if (condition()) {
-      repeated.stop();
-      state.resolver?.();
-    }
-  }, {
-    afterCallback() {
-      if (!repeated.paused) {
-        if (condition()) {
-          state.resolver?.();
-        } else {
-          state.rejecter?.();
-        }
-      }
-    },
-    errorCallback() {
-      state.rejecter?.();
-    },
-    count: options?.count,
-    interval: options?.interval,
-    timeout: options?.timeout
-  }, false);
-  const state = {};
-  state.promise = new Promise((resolve, reject) => {
-    state.resolver = resolve;
-    state.rejecter = reject;
-  });
-  state.timer = repeated;
-  return new When(state);
-}
-
-class When extends BasicTimer {
-  get active() {
-    return this.state.timer.active;
-  }
-  get paused() {
-    return this.state.timer.paused;
-  }
-  constructor(state) {
-    super("when", state);
-  }
-  continue() {
-    this.state.timer.continue();
-    return this;
-  }
-  pause() {
-    this.state.timer.pause();
-    return this;
-  }
-  stop() {
-    if (this.state.timer.active) {
-      this.state.timer.stop();
-      this.state.rejecter?.();
-    }
-    return this;
-  }
-  then(resolve, reject) {
-    this.state.timer.start();
-    return this.state.promise.then(resolve ?? noop, reject ?? noop);
-  }
-}
-
-// src/index.ts
-document.addEventListener("visibilitychange", () => {
-  if (document.hidden) {
-    for (const timer4 of activeTimers) {
-      hiddenTimers.add(timer4);
-      timer4.pause();
-    }
-  } else {
-    for (const timer4 of hiddenTimers) {
-      timer4.continue();
-    }
-    hiddenTimers.clear();
-  }
-});
 export {
-  when,
   wait,
+  timer,
   repeat,
-  isWhen,
-  isWaited,
-  isTimer,
-  isRepeated,
-  delay
+  Timer,
+  BasicTimer
 };

package/dist/timer.mjs

@@ -1,40 +1,79 @@
-// src/index.ts
-import {noop} from "@oscarpalmer/atoms/function";
-import {activeTimers, hiddenTimers} from "./constants";
-import"./global";
-import {wait} from "./timer";
-function delay(time, timeout) {
-  return new Promise((resolve, reject) => {
-    wait(resolve ?? noop, {
-      timeout,
-      errorCallback: reject ?? noop,
-      interval: time
-    });
-  });
+// src/timer.ts
+import {milliseconds} from "./constants";
+import {getOptions, work} from "./functions";
+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,
+    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 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);
+  }
+  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);
+  }
+}
+
+class TimerTrace extends Error {
+  constructor() {
+    super();
+    this.name = "TimerTrace";
+  }
 }
-import {isRepeated, isTimer, isWaited, isWhen} from "./is";
-import {repeat, wait as wait2} from "./timer";
-import {when} from "./when";
-document.addEventListener("visibilitychange", () => {
-  if (document.hidden) {
-    for (const timer2 of activeTimers) {
-      hiddenTimers.add(timer2);
-      timer2.pause();
-    }
-  } else {
-    for (const timer2 of hiddenTimers) {
-      timer2.continue();
-    }
-    hiddenTimers.clear();
-  }
-});
 export {
-  when,
-  wait2 as wait,
+  wait,
+  timer,
   repeat,
-  isWhen,
-  isWaited,
-  isTimer,
-  isRepeated,
-  delay
+  Timer,
+  BasicTimer
 };

package/dist/when.js

@@ -0,0 +1,226 @@
+// node_modules/@oscarpalmer/atoms/dist/js/function.mjs
+function noop() {
+}
+
+// src/constants.ts
+var activeTimers = new Set;
+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 (["continue", "start"].includes(type) && state.active || ["pause", "stop"].includes(type) && !state.active) {
+    return timer;
+  }
+  const { count, interval, timeout } = options;
+  const { isRepeated, minimum } = state;
+  if (["pause", "restart", "stop"].includes(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/timer.ts
+function timer(type, callback, partial, start) {
+  const isRepeated = type === "repeat";
+  const options = getOptions(partial, isRepeated);
+  const instance = new Timer(type, {
+    callback,
+    isRepeated,
+    active: false,
+    minimum: options.interval - options.interval % milliseconds / 2,
+    paused: false,
+    trace: new TimerTrace
+  }, options);
+  if (start) {
+    instance.start();
+  }
+  return instance;
+}
+class BasicTimer {
+  constructor(type, state) {
+    this.$timer = type;
+    this.state = state;
+  }
+}
+
+class Timer extends BasicTimer {
+  get active() {
+    return this.state.active;
+  }
+  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);
+  }
+  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);
+  }
+}
+
+class TimerTrace extends Error {
+  constructor() {
+    super();
+    this.name = "TimerTrace";
+  }
+}
+
+// src/when.ts
+function when(condition, options) {
+  const repeated = timer("repeat", () => {
+    if (condition()) {
+      repeated.stop();
+      state.resolver?.();
+    }
+  }, {
+    afterCallback() {
+      if (!repeated.paused) {
+        if (condition()) {
+          state.resolver?.();
+        } else {
+          state.rejecter?.();
+        }
+      }
+    },
+    errorCallback() {
+      state.rejecter?.();
+    },
+    count: options?.count,
+    interval: options?.interval,
+    timeout: options?.timeout
+  }, false);
+  const state = {};
+  state.promise = new Promise((resolve, reject) => {
+    state.resolver = resolve;
+    state.rejecter = reject;
+  });
+  state.timer = repeated;
+  return new When(state);
+}
+
+class When extends BasicTimer {
+  get active() {
+    return this.state.timer.active;
+  }
+  get paused() {
+    return this.state.timer.paused;
+  }
+  constructor(state) {
+    super("when", state);
+  }
+  continue() {
+    this.state.timer.continue();
+    return this;
+  }
+  pause() {
+    this.state.timer.pause();
+    return this;
+  }
+  stop() {
+    if (this.state.timer.active) {
+      this.state.timer.stop();
+      this.state.rejecter?.();
+    }
+    return this;
+  }
+  then(resolve, reject) {
+    this.state.timer.start();
+    return this.state.promise.then(resolve ?? noop, reject ?? noop);
+  }
+}
+export {
+  when,
+  When
+};

package/dist/when.mjs

@@ -0,0 +1,69 @@
+// src/when.ts
+import {noop} from "@oscarpalmer/atoms/function";
+import {BasicTimer, timer as timer2} from "./timer";
+function when(condition, options) {
+  const repeated = timer2("repeat", () => {
+    if (condition()) {
+      repeated.stop();
+      state.resolver?.();
+    }
+  }, {
+    afterCallback() {
+      if (!repeated.paused) {
+        if (condition()) {
+          state.resolver?.();
+        } else {
+          state.rejecter?.();
+        }
+      }
+    },
+    errorCallback() {
+      state.rejecter?.();
+    },
+    count: options?.count,
+    interval: options?.interval,
+    timeout: options?.timeout
+  }, false);
+  const state = {};
+  state.promise = new Promise((resolve, reject) => {
+    state.resolver = resolve;
+    state.rejecter = reject;
+  });
+  state.timer = repeated;
+  return new When(state);
+}
+
+class When extends BasicTimer {
+  get active() {
+    return this.state.timer.active;
+  }
+  get paused() {
+    return this.state.timer.paused;
+  }
+  constructor(state) {
+    super("when", state);
+  }
+  continue() {
+    this.state.timer.continue();
+    return this;
+  }
+  pause() {
+    this.state.timer.pause();
+    return this;
+  }
+  stop() {
+    if (this.state.timer.active) {
+      this.state.timer.stop();
+      this.state.rejecter?.();
+    }
+    return this;
+  }
+  then(resolve, reject) {
+    this.state.timer.start();
+    return this.state.promise.then(resolve ?? noop, reject ?? noop);
+  }
+}
+export {
+  when,
+  When
+};

package/package.json

@@ -20,36 +20,35 @@
 			"bun": "./src/index.ts",
 			"import": {
 				"types": "./types/index.d.ts",
-				"default": "./dist/timer.mjs"
+				"default": "./dist/index.mjs"
 			},
 			"require": {
 				"types": "./types/index.d.cts",
-				"default": "./dist/timer.js"
+				"default": "./dist/index.js"
 			}
 		}
 	},
 	"files": ["dist", "src", "types"],
 	"keywords": ["timer", "setTimeout", "setInterval", "requestAnimationFrame"],
 	"license": "MIT",
-	"main": "dist/timer.js",
-	"module": "dist/timer.mjs",
+	"main": "dist/index.js",
+	"module": "dist/index.mjs",
 	"name": "@oscarpalmer/timer",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/oscarpalmer/timer.git"
 	},
 	"scripts": {
-		"build": "bun run clean && bun run build:cjs && bun run build:esm && bun run types",
-		"build:cjs": "bun build ./src/index.ts --outfile ./dist/timer.js",
-		"build:esm": "bun build ./src/index.ts --external '*' --outfile ./dist/timer.mjs",
+		"build": "bun run clean && bun run build:js && bun run types",
+		"build:js": "bunx bun ./.bun.ts && bunx bun ./.bun.ts --mjs",
 		"clean": "rm -rf ./dist && rm -rf ./types && rm -f ./tsconfig.tsbuildinfo",
 		"test": "bun test",
 		"types": "bun run types:cjs && bun run types:esm",
 		"types:cjs": "bunx dts-bundle-generator --out-file ./types/index.d.cts --external-inlines '@oscarpalmer/atoms' --no-check --silent ./src/index.ts",
 		"types:esm": "bunx tsc -p ./tsconfig.json",
-		"watch": "bun build ./src/index.ts --outfile ./dist/timer.js --watch"
+		"watch": "bun build ./src/index.ts --outfile ./dist/index.js --watch"
 	},
 	"type": "module",
 	"types": "types/index.d.cts",
-	"version": "0.21.1"
+	"version": "0.22.1"
 }