@oscarpalmer/timer 0.22.1 → 0.24.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,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;
 
@@ -17,12 +24,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);

package/dist/functions.mjs

@@ -1,5 +1,11 @@
 // src/functions.ts
-import {activeTimers, milliseconds} from "./constants";
+import {
+activeTimers,
+beginTypes,
+endOrRestartTypes,
+endTypes,
+milliseconds
+} from "./constants";
 function getOptions(options, isRepeated) {
   return {
     afterCallback: options.afterCallback,
@@ -13,12 +19,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);

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;
 
@@ -30,12 +37,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 +111,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 +130,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 +157,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 +173,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 +197,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 +232,85 @@ 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?.();
-        }
+  let result = false;
+  const state = {
+    started: false,
+    timer: timer("repeat", () => {
+      if (condition()) {
+        result = true;
+        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 (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.timer = repeated;
-  return new When(state);
+  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;
+    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() {
+    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();
+    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) {
+      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);
   }

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

@@ -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;
 
@@ -17,12 +24,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);
@@ -91,6 +98,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);
@@ -102,6 +117,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
@@ -128,6 +144,9 @@ class Timer extends BasicTimer {
   get active() {
     return this.state.active;
   }
+  get destroyed() {
+    return this.state.destroyed;
+  }
   get paused() {
     return this.state.paused;
   }
@@ -141,6 +160,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);
   }
@@ -154,13 +183,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,

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,