@oscarpalmer/timer 0.22.0 → 0.23.0

package/dist/constants.js

@@ -1,9 +1,19 @@
 // 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;
 export {
   milliseconds,
   hiddenTimers,
+  endTypes,
+  endOrRestartTypes,
+  beginTypes,
   activeTimers
 };

package/dist/constants.mjs

@@ -1,9 +1,19 @@
 // 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;
 export {
   milliseconds,
   hiddenTimers,
+  endTypes,
+  endOrRestartTypes,
+  beginTypes,
   activeTimers
 };

package/dist/functions.js

@@ -1,9 +1,23 @@
 // 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 destroyWhen(state) {
+  state.timer?.destroy();
+  state.promise = undefined;
+  state.rejecter = undefined;
+  state.resolver = undefined;
+  state.timer = undefined;
+}
 function getOptions(options, isRepeated) {
   return {
     afterCallback: options.afterCallback,
@@ -17,12 +31,12 @@ 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) {
+  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 (["pause", "restart", "stop"].includes(type)) {
+  if (endOrRestartTypes.has(type)) {
     const isStop = type === "stop";
     activeTimers.delete(timer);
     cancelAnimationFrame(state.frame);
@@ -93,5 +107,6 @@ function work(type, timer, state, options) {
 export {
   work,
   getValueOrDefault,
-  getOptions
+  getOptions,
+  destroyWhen
 };

package/dist/functions.mjs

@@ -1,5 +1,18 @@
 // src/functions.ts
-import {activeTimers, milliseconds} from "./constants";
+import {
+activeTimers,
+beginTypes,
+endOrRestartTypes,
+endTypes,
+milliseconds
+} from "./constants";
+function destroyWhen(state) {
+  state.timer?.destroy();
+  state.promise = undefined;
+  state.rejecter = undefined;
+  state.resolver = undefined;
+  state.timer = undefined;
+}
 function getOptions(options, isRepeated) {
   return {
     afterCallback: options.afterCallback,
@@ -13,12 +26,12 @@ 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) {
+  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 (["pause", "restart", "stop"].includes(type)) {
+  if (endOrRestartTypes.has(type)) {
     const isStop = type === "stop";
     activeTimers.delete(timer);
     cancelAnimationFrame(state.frame);
@@ -89,5 +102,6 @@ function work(type, timer, state, options) {
 export {
   work,
   getValueOrDefault,
-  getOptions
+  getOptions,
+  destroyWhen
 };

package/dist/global.js

@@ -1,5 +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;
 

package/dist/index.js

@@ -4,6 +4,13 @@ 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;
 
@@ -17,6 +24,13 @@ if (globalThis._oscarpalmer_timers == null) {
 }
 
 // src/functions.ts
+function destroyWhen(state) {
+  state.timer?.destroy();
+  state.promise = undefined;
+  state.rejecter = undefined;
+  state.resolver = undefined;
+  state.timer = undefined;
+}
 function getOptions(options, isRepeated) {
   return {
     afterCallback: options.afterCallback,
@@ -30,12 +44,12 @@ 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) {
+  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 (["pause", "restart", "stop"].includes(type)) {
+  if (endOrRestartTypes.has(type)) {
     const isStop = type === "stop";
     activeTimers.delete(timer);
     cancelAnimationFrame(state.frame);
@@ -104,6 +118,14 @@ function work(type, timer, state, options) {
   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);
@@ -115,6 +137,7 @@ function timer(type, callback, partial, start) {
     callback,
     isRepeated,
     active: false,
+    destroyed: false,
     minimum: options.interval - options.interval % milliseconds / 2,
     paused: false,
     trace: new TimerTrace
@@ -141,6 +164,9 @@ class Timer extends BasicTimer {
   get active() {
     return this.state.active;
   }
+  get destroyed() {
+    return this.state.destroyed;
+  }
   get paused() {
     return this.state.paused;
   }
@@ -154,6 +180,16 @@ class Timer extends BasicTimer {
   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);
   }
@@ -168,19 +204,18 @@ class Timer extends BasicTimer {
   }
 }
 
-class TimerTrace extends Error {
-  constructor() {
-    super();
-    this.name = "TimerTrace";
-  }
-}
-
 // src/index.ts
 function delay(time, timeout) {
   return new Promise((resolve, reject) => {
-    wait(resolve ?? noop, {
+    const delayed = wait(() => {
+      delayed.destroy();
+      (resolve ?? noop)();
+    }, {
       timeout,
-      errorCallback: reject ?? noop,
+      errorCallback: () => {
+        delayed.destroy();
+        (reject ?? noop)();
+      },
       interval: time
     });
   });
@@ -204,63 +239,80 @@ function isWhen(value) {
 }
 // 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?.();
-        }
+  const state = {
+    started: false,
+    timer: timer("repeat", () => {
+      if (condition()) {
+        state.timer.stop();
       }
-    },
-    errorCallback() {
-      state.rejecter?.();
-    },
-    count: options?.count,
-    interval: options?.interval,
-    timeout: options?.timeout
-  }, false);
-  const state = {};
-  state.promise = new Promise((resolve, reject) => {
+    }, {
+      afterCallback() {
+        if (!state.timer.paused) {
+          if (condition()) {
+            state.resolver?.();
+          } else {
+            state.rejecter?.();
+          }
+          destroyWhen(state);
+        }
+      },
+      errorCallback() {
+        state.rejecter?.();
+        destroyWhen(state);
+      },
+      count: options?.count,
+      interval: options?.interval,
+      timeout: options?.timeout
+    }, false)
+  };
+  const promise = new Promise((resolve, reject) => {
     state.resolver = resolve;
     state.rejecter = reject;
   });
-  state.timer = repeated;
+  state.promise = promise;
   return new When(state);
 }
 
 class When extends BasicTimer {
   get active() {
-    return this.state.timer.active;
+    return this.state.timer?.active ?? false;
+  }
+  get destroyed() {
+    return this.state.timer == null;
   }
   get paused() {
-    return this.state.timer.paused;
+    return this.state.timer?.paused ?? false;
+  }
+  get trace() {
+    return this.state.timer?.trace;
   }
   constructor(state) {
     super("when", state);
   }
   continue() {
-    this.state.timer.continue();
+    this.state.timer?.continue();
     return this;
   }
+  destroy() {
+    if (this.state.timer != null) {
+      this.state.timer.destroy();
+    }
+  }
   pause() {
-    this.state.timer.pause();
+    this.state.timer?.pause();
     return this;
   }
   stop() {
-    if (this.state.timer.active) {
-      this.state.timer.stop();
-      this.state.rejecter?.();
-    }
+    this.state.timer?.stop();
     return this;
   }
   then(resolve, reject) {
+    if (this.state.timer == null || this.state.started) {
+      return new Promise(() => {
+        (reject ?? noop)();
+      });
+    }
+    this.state.started = true;
     this.state.timer.start();
     return this.state.promise.then(resolve ?? noop, reject ?? noop);
   }

package/dist/index.mjs

@@ -5,9 +5,15 @@ import"./global";
 import {wait} from "./timer";
 function delay(time, timeout) {
   return new Promise((resolve, reject) => {
-    wait(resolve ?? noop, {
+    const delayed = wait(() => {
+      delayed.destroy();
+      (resolve ?? noop)();
+    }, {
       timeout,
-      errorCallback: reject ?? noop,
+      errorCallback: () => {
+        delayed.destroy();
+        (reject ?? noop)();
+      },
       interval: time
     });
   });

package/dist/models.mjs

@@ -0,0 +1,10 @@
+// src/models.ts
+class TimerTrace extends Error {
+  constructor() {
+    super();
+    this.name = "TimerTrace";
+  }
+}
+export {
+  TimerTrace
+};

package/dist/timer.js

@@ -0,0 +1,192 @@
+// 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);
+}
+
+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);
+  }
+}
+export {
+  wait,
+  timer,
+  repeat,
+  Timer,
+  BasicTimer
+};

package/dist/timer.mjs

@@ -1,6 +1,9 @@
 // src/timer.ts
 import {milliseconds} from "./constants";
 import {getOptions, work} from "./functions";
+import {
+TimerTrace
+} from "./models";
 function repeat(callback, options) {
   return timer("repeat", callback, options ?? {}, true);
 }
@@ -11,6 +14,7 @@ function timer(type, callback, partial, start) {
     callback,
     isRepeated,
     active: false,
+    destroyed: false,
     minimum: options.interval - options.interval % milliseconds / 2,
     paused: false,
     trace: new TimerTrace
@@ -37,6 +41,9 @@ class Timer extends BasicTimer {
   get active() {
     return this.state.active;
   }
+  get destroyed() {
+    return this.state.destroyed;
+  }
   get paused() {
     return this.state.paused;
   }
@@ -50,6 +57,16 @@ class Timer extends BasicTimer {
   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);
   }
@@ -63,13 +80,6 @@ class Timer extends BasicTimer {
     return work("stop", this, this.state, this.options);
   }
 }
-
-class TimerTrace extends Error {
-  constructor() {
-    super();
-    this.name = "TimerTrace";
-  }
-}
 export {
   wait,
   timer,