@oscarpalmer/timer 0.22.0 → 0.22.1

package/dist/timer.js

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

package/package.json

@@ -20,7 +20,7 @@
 			"bun": "./src/index.ts",
 			"import": {
 				"types": "./types/index.d.ts",
-				"default": "./dist/timer.mjs"
+				"default": "./dist/index.mjs"
 			},
 			"require": {
 				"types": "./types/index.d.cts",
@@ -46,9 +46,9 @@
 		"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.22.0"
+	"version": "0.22.1"
 }