elements-kit 0.0.8 → 0.0.9

package/dist/signals/index.d.mts

@@ -1,2 +1,2 @@
-import { _ as untracked, a as reactive, c as effect, d as isEffect, f as isEffectScope, g as trigger, h as signal, i as isReactive, l as effectScope, m as onCleanup, n as Signal, o as batch, p as isSignal, r as Updater, s as computed, t as Computed, u as isComputed } from "../index-BGKVkZ6y.mjs";
+import { _ as untracked, a as reactive, c as effect, d as isEffect, f as isEffectScope, g as trigger, h as signal, i as isReactive, l as effectScope, m as onCleanup, n as Signal, o as batch, p as isSignal, r as Updater, s as computed, t as Computed, u as isComputed } from "../index-BtqiEEfc.mjs";
 export { Computed, Signal, Updater, batch, computed, effect, effectScope, isComputed, isEffect, isEffectScope, isReactive, isSignal, onCleanup, reactive, signal, trigger, untracked };

package/dist/signals/lib/active-element.d.mts

@@ -0,0 +1,10 @@
+import { t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/active-element.d.ts
+/**
+ * Returns a `Computed` that tracks `document.activeElement`.
+ * Updates on every `focusin` / `focusout` event bubbling through the document.
+ */
+declare function createActiveElement(): Computed<Element | null> & Disposable;
+//#endregion
+export { createActiveElement };

package/dist/signals/lib/active-element.mjs

@@ -0,0 +1,20 @@
+import { f as signal } from "../../signals-CLAPw8kk.mjs";
+import { createEventListener } from "./event-listener.mjs";
+//#region src/signals/lib/active-element.ts
+/**
+* Returns a `Computed` that tracks `document.activeElement`.
+* Updates on every `focusin` / `focusout` event bubbling through the document.
+*/
+function createActiveElement() {
+	const active = signal(typeof document !== "undefined" ? document.activeElement : null);
+	const update = () => active(document.activeElement);
+	const r1 = createEventListener(document, "focusin", update);
+	const r2 = createEventListener(document, "focusout", update);
+	const cleanup = () => {
+		r1();
+		r2();
+	};
+	return Object.assign(active, { [Symbol.dispose]: cleanup });
+}
+//#endregion
+export { createActiveElement };

package/dist/signals/lib/active-element.test.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/signals/lib/active-element.test.mjs

@@ -0,0 +1,39 @@
+import { o as effectScope } from "../../signals-CLAPw8kk.mjs";
+import { a as describe, o as it, r as afterEach, t as globalExpect } from "../../test.BmQO5GaM-CR2qjV1t.mjs";
+import { createActiveElement } from "./active-element.mjs";
+//#region src/signals/lib/active-element.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+});
+describe("createActiveElement", () => {
+	it("returns a computed that reads the current activeElement", () => {
+		let active;
+		effectScope(() => {
+			active = createActiveElement();
+		});
+		globalExpect(active()).toBe(document.activeElement);
+	});
+	it("updates when focus changes", () => {
+		const input = document.createElement("input");
+		document.body.appendChild(input);
+		let active;
+		effectScope(() => {
+			active = createActiveElement();
+		});
+		document.dispatchEvent(new FocusEvent("focusin", { relatedTarget: input }));
+		globalExpect(active()).toBe(document.activeElement);
+	});
+	it("stops updating after Symbol.dispose", () => {
+		let active;
+		effectScope(() => {
+			active = createActiveElement();
+		});
+		active[Symbol.dispose]();
+		const input = document.createElement("input");
+		document.body.appendChild(input);
+		input.focus();
+		globalExpect(typeof active()).not.toBe("undefined");
+	});
+});
+//#endregion
+export {};

package/dist/signals/lib/animation-frames.d.mts

@@ -0,0 +1,18 @@
+import { t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/animation-frames.d.ts
+type AnimationFramesResult = {
+  isRunning: Computed<boolean>;
+  delta: Computed<number>;
+  elapsed: Computed<number>;
+  start(): void;
+  stop(): void;
+} & Disposable;
+/**
+ * RAF loop with pause/resume, delta time, and elapsed time tracking.
+ *
+ * Starts paused — call `start()` to begin.
+ */
+declare function createAnimationFrames(): AnimationFramesResult;
+//#endregion
+export { createAnimationFrames };

package/dist/signals/lib/animation-frames.mjs

@@ -0,0 +1,48 @@
+import { d as onCleanup, f as signal } from "../../signals-CLAPw8kk.mjs";
+//#region src/signals/lib/animation-frames.ts
+/**
+* RAF loop with pause/resume, delta time, and elapsed time tracking.
+*
+* Starts paused — call `start()` to begin.
+*/
+function createAnimationFrames() {
+	const isRunning = signal(false);
+	const delta = signal(0);
+	const elapsed = signal(0);
+	let rafId;
+	let lastTime;
+	const loop = (time) => {
+		if (lastTime !== void 0) {
+			const d = time - lastTime;
+			delta(d);
+			elapsed(elapsed() + d);
+		}
+		lastTime = time;
+		rafId = requestAnimationFrame(loop);
+	};
+	const start = () => {
+		if (isRunning()) return;
+		lastTime = void 0;
+		isRunning(true);
+		rafId = requestAnimationFrame(loop);
+	};
+	const stop = () => {
+		if (rafId !== void 0) {
+			cancelAnimationFrame(rafId);
+			rafId = void 0;
+		}
+		lastTime = void 0;
+		isRunning(false);
+	};
+	const cleanup = () => stop();
+	onCleanup(cleanup);
+	return Object.assign({
+		isRunning,
+		delta,
+		elapsed,
+		start,
+		stop
+	}, { [Symbol.dispose]: cleanup });
+}
+//#endregion
+export { createAnimationFrames };

package/dist/signals/lib/animation-frames.test.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/signals/lib/animation-frames.test.mjs

@@ -0,0 +1,52 @@
+import { o as effectScope } from "../../signals-CLAPw8kk.mjs";
+import { a as describe, n as vi, o as it, r as afterEach, t as globalExpect } from "../../test.BmQO5GaM-CR2qjV1t.mjs";
+import { createAnimationFrames } from "./animation-frames.mjs";
+//#region src/signals/lib/animation-frames.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+	vi.unstubAllGlobals();
+});
+describe("createAnimationFrames", () => {
+	it("starts paused", () => {
+		let af;
+		effectScope(() => {
+			af = createAnimationFrames();
+		});
+		globalExpect(af.isRunning()).toBe(false);
+	});
+	it("start() sets isRunning to true", () => {
+		vi.stubGlobal("requestAnimationFrame", vi.fn().mockReturnValue(1));
+		vi.stubGlobal("cancelAnimationFrame", vi.fn());
+		let af;
+		effectScope(() => {
+			af = createAnimationFrames();
+		});
+		af.start();
+		globalExpect(af.isRunning()).toBe(true);
+	});
+	it("stop() sets isRunning to false", () => {
+		vi.stubGlobal("requestAnimationFrame", vi.fn().mockReturnValue(1));
+		vi.stubGlobal("cancelAnimationFrame", vi.fn());
+		let af;
+		effectScope(() => {
+			af = createAnimationFrames();
+		});
+		af.start();
+		af.stop();
+		globalExpect(af.isRunning()).toBe(false);
+	});
+	it("Symbol.dispose stops the loop", () => {
+		const cancel = vi.fn();
+		vi.stubGlobal("requestAnimationFrame", vi.fn().mockReturnValue(1));
+		vi.stubGlobal("cancelAnimationFrame", cancel);
+		let af;
+		effectScope(() => {
+			af = createAnimationFrames();
+		});
+		af.start();
+		af[Symbol.dispose]();
+		globalExpect(cancel).toHaveBeenCalled();
+	});
+});
+//#endregion
+export {};

package/dist/signals/lib/async-retry.d.mts

@@ -0,0 +1,21 @@
+import { t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/async-retry.d.ts
+type AsyncRetryResult<T> = {
+  data: Computed<T | undefined>;
+  loading: Computed<boolean>;
+  error: Computed<unknown>;
+  retry(): void;
+  attempt: Computed<number>;
+};
+/**
+ * Like `createResource` but automatically retries on failure up to
+ * `maxRetries` times with an exponential-back-off delay.
+ */
+declare function createAsyncRetry<S, T>(source: () => S, fetcher: (source: S, signal: AbortSignal) => Promise<T>, options?: {
+  initialValue?: T;
+  maxRetries?: number;
+  delay?: number;
+}): AsyncRetryResult<T>;
+//#endregion
+export { createAsyncRetry };

package/dist/signals/lib/async-retry.mjs

@@ -0,0 +1,57 @@
+import { a as effect, d as onCleanup, f as signal } from "../../signals-CLAPw8kk.mjs";
+//#region src/signals/lib/async-retry.ts
+/**
+* Like `createResource` but automatically retries on failure up to
+* `maxRetries` times with an exponential-back-off delay.
+*/
+function createAsyncRetry(source, fetcher, options) {
+	const { maxRetries = 3, delay = 1e3 } = options ?? {};
+	const data = signal(options?.initialValue);
+	const loading = signal(false);
+	const error = signal(void 0);
+	const attempt = signal(0);
+	const tick = signal(0);
+	effect(() => {
+		tick();
+		const src = source();
+		const controller = new AbortController();
+		loading(true);
+		error(void 0);
+		attempt(0);
+		let currentAttempt = 0;
+		const run = () => {
+			fetcher(src, controller.signal).then((result) => {
+				data(result);
+				loading(false);
+			}, (err) => {
+				if (err.name === "AbortError") return;
+				if (currentAttempt < maxRetries) {
+					currentAttempt++;
+					attempt(currentAttempt);
+					const retryTimer = setTimeout(run, delay * 2 ** (currentAttempt - 1));
+					const orig = cleanup;
+					cleanup = () => {
+						clearTimeout(retryTimer);
+						orig();
+					};
+				} else {
+					error(err);
+					loading(false);
+				}
+			});
+		};
+		let cleanup = () => controller.abort();
+		run();
+		onCleanup(() => cleanup());
+	});
+	const retry = () => tick(tick() + 1);
+	return {
+		data,
+		loading,
+		error,
+		attempt,
+		retry
+	};
+}
+//#endregion
+export { createAsyncRetry };

package/dist/signals/lib/async-retry.test.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/signals/lib/async-retry.test.mjs

@@ -0,0 +1,57 @@
+import { o as effectScope } from "../../signals-CLAPw8kk.mjs";
+import { a as describe, n as vi, o as it, r as afterEach, t as globalExpect } from "../../test.BmQO5GaM-CR2qjV1t.mjs";
+import { createAsyncRetry } from "./async-retry.mjs";
+//#region src/signals/lib/async-retry.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+	vi.useRealTimers();
+});
+describe("createAsyncRetry", () => {
+	it("resolves successfully on first try", async () => {
+		const src = () => "url";
+		let r;
+		effectScope(() => {
+			r = createAsyncRetry(src, async () => "ok");
+		});
+		await new Promise((res) => setTimeout(res, 0));
+		globalExpect(r.data()).toBe("ok");
+		globalExpect(r.loading()).toBe(false);
+	});
+	it("retries on failure and eventually resolves", async () => {
+		vi.useFakeTimers();
+		let calls = 0;
+		const src = () => "url";
+		let r;
+		effectScope(() => {
+			r = createAsyncRetry(src, async () => {
+				calls++;
+				if (calls < 3) throw new Error("fail");
+				return "success";
+			}, {
+				maxRetries: 3,
+				delay: 100
+			});
+		});
+		await vi.runAllTicks();
+		await vi.runAllTimersAsync();
+		globalExpect(r.data()).toBe("success");
+	}, 1e4);
+	it("sets error after exhausting retries", async () => {
+		vi.useFakeTimers();
+		const src = () => "url";
+		let r;
+		effectScope(() => {
+			r = createAsyncRetry(src, async () => {
+				throw new Error("persistent");
+			}, {
+				maxRetries: 2,
+				delay: 50
+			});
+		});
+		await vi.runAllTimersAsync();
+		globalExpect(r.error()).toBeInstanceOf(Error);
+		globalExpect(r.loading()).toBe(false);
+	}, 1e4);
+});
+//#endregion
+export {};

package/dist/signals/lib/audio.d.mts

@@ -0,0 +1,26 @@
+import { t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/audio.d.ts
+type AudioResult = {
+  element: HTMLAudioElement;
+  playing: Computed<boolean>;
+  muted: Computed<boolean>;
+  volume: Computed<number>;
+  duration: Computed<number>;
+  time: Computed<number>;
+  ended: Computed<boolean>;
+  play(): void;
+  pause(): void;
+  toggle(): void;
+  setVolume(v: number): void;
+  setTime(t: number): void;
+  mute(): void;
+  unmute(): void;
+} & Disposable;
+/**
+ * Wraps an `HTMLAudioElement` with reactive state and playback controls.
+ * Pass a `src` string to create a new element, or pass an existing element.
+ */
+declare function createAudio(src: string | HTMLAudioElement): AudioResult;
+//#endregion
+export { createAudio };

package/dist/signals/lib/audio.mjs

@@ -0,0 +1,60 @@
+import { f as signal } from "../../signals-CLAPw8kk.mjs";
+import { createEventListener } from "./event-listener.mjs";
+//#region src/signals/lib/audio.ts
+/**
+* Wraps an `HTMLAudioElement` with reactive state and playback controls.
+* Pass a `src` string to create a new element, or pass an existing element.
+*/
+function createAudio(src) {
+	const el = typeof src === "string" ? new Audio(src) : src;
+	const playing = signal(!el.paused);
+	const muted = signal(el.muted);
+	const volume = signal(el.volume);
+	const duration = signal(el.duration || 0);
+	const time = signal(el.currentTime);
+	const ended = signal(el.ended);
+	const onPlay = () => playing(true);
+	const onPause = () => playing(false);
+	const onVolumeChange = () => {
+		muted(el.muted);
+		volume(el.volume);
+	};
+	const onDurationChange = () => duration(el.duration);
+	const onTimeUpdate = () => time(el.currentTime);
+	const onEnded = () => ended(true);
+	const cleanups = [
+		createEventListener(el, "play", onPlay),
+		createEventListener(el, "pause", onPause),
+		createEventListener(el, "volumechange", onVolumeChange),
+		createEventListener(el, "durationchange", onDurationChange),
+		createEventListener(el, "timeupdate", onTimeUpdate),
+		createEventListener(el, "ended", onEnded)
+	];
+	const cleanup = () => cleanups.forEach((fn) => fn());
+	return Object.assign({
+		element: el,
+		playing,
+		muted,
+		volume,
+		duration,
+		time,
+		ended,
+		play: () => el.play(),
+		pause: () => el.pause(),
+		toggle: () => el.paused ? el.play() : el.pause(),
+		setVolume: (v) => {
+			el.volume = Math.min(1, Math.max(0, v));
+		},
+		setTime: (t) => {
+			el.currentTime = t;
+		},
+		mute: () => {
+			el.muted = true;
+		},
+		unmute: () => {
+			el.muted = false;
+		}
+	}, { [Symbol.dispose]: cleanup });
+}
+//#endregion
+export { createAudio };

package/dist/signals/lib/audio.test.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/signals/lib/audio.test.mjs

@@ -0,0 +1,54 @@
+import { o as effectScope } from "../../signals-CLAPw8kk.mjs";
+import { a as describe, n as vi, o as it, r as afterEach, t as globalExpect } from "../../test.BmQO5GaM-CR2qjV1t.mjs";
+import { createAudio } from "./audio.mjs";
+//#region src/signals/lib/audio.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+	vi.restoreAllMocks();
+});
+describe("createAudio", () => {
+	it("creates an Audio element from a src string", () => {
+		let a;
+		effectScope(() => {
+			a = createAudio("test.mp3");
+		});
+		globalExpect(a.element).toBeInstanceOf(HTMLAudioElement);
+	});
+	it("starts as paused", () => {
+		let a;
+		effectScope(() => {
+			a = createAudio("test.mp3");
+		});
+		globalExpect(a.playing()).toBe(false);
+	});
+	it("mute() sets muted to true", () => {
+		let a;
+		effectScope(() => {
+			a = createAudio("test.mp3");
+		});
+		a.mute();
+		globalExpect(a.element.muted).toBe(true);
+	});
+	it("setVolume clamps to [0, 1]", () => {
+		let a;
+		effectScope(() => {
+			a = createAudio("test.mp3");
+		});
+		a.setVolume(2);
+		globalExpect(a.element.volume).toBe(1);
+		a.setVolume(-1);
+		globalExpect(a.element.volume).toBe(0);
+	});
+	it("removes event listeners on Symbol.dispose", () => {
+		const removeSpy = vi.fn();
+		let a;
+		effectScope(() => {
+			a = createAudio("test.mp3");
+		});
+		vi.spyOn(a.element, "removeEventListener").mockImplementation(removeSpy);
+		a[Symbol.dispose]();
+		globalExpect(removeSpy).toHaveBeenCalled();
+	});
+});
+//#endregion
+export {};

package/dist/signals/lib/battery.d.mts

@@ -0,0 +1,17 @@
+import { t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/battery.d.ts
+type BatteryResult = {
+  charging: Computed<boolean>;
+  level: Computed<number>;
+  chargingTime: Computed<number>;
+  dischargingTime: Computed<number>;
+  supported: Computed<boolean>;
+} & Disposable;
+/**
+ * Exposes the Battery Status API as reactive signals.
+ * `supported` will be `false` when the API is unavailable.
+ */
+declare function createBattery(): BatteryResult;
+//#endregion
+export { createBattery };

package/dist/signals/lib/battery.mjs

@@ -0,0 +1,45 @@
+import { d as onCleanup, f as signal } from "../../signals-CLAPw8kk.mjs";
+//#region src/signals/lib/battery.ts
+/**
+* Exposes the Battery Status API as reactive signals.
+* `supported` will be `false` when the API is unavailable.
+*/
+function createBattery() {
+	const supported = signal(typeof navigator !== "undefined" && "getBattery" in navigator);
+	const charging = signal(false);
+	const level = signal(1);
+	const chargingTime = signal(0);
+	const dischargingTime = signal(Infinity);
+	let battery;
+	const update = () => {
+		if (!battery) return;
+		charging(battery.charging);
+		level(battery.level);
+		chargingTime(battery.chargingTime);
+		dischargingTime(battery.dischargingTime);
+	};
+	const events = [
+		"chargingchange",
+		"levelchange",
+		"chargingtimechange",
+		"dischargingtimechange"
+	];
+	const cleanup = () => {
+		events.forEach((e) => battery?.removeEventListener(e, update));
+	};
+	if (supported()) navigator.getBattery().then((b) => {
+		battery = b;
+		update();
+		events.forEach((e) => b.addEventListener(e, update));
+	});
+	onCleanup(cleanup);
+	return Object.assign({
+		supported,
+		charging,
+		level,
+		chargingTime,
+		dischargingTime
+	}, { [Symbol.dispose]: cleanup });
+}
+//#endregion
+export { createBattery };

package/dist/signals/lib/battery.test.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/signals/lib/battery.test.mjs

@@ -0,0 +1,38 @@
+import { o as effectScope } from "../../signals-CLAPw8kk.mjs";
+import { a as describe, n as vi, o as it, r as afterEach, t as globalExpect } from "../../test.BmQO5GaM-CR2qjV1t.mjs";
+import { createBattery } from "./battery.mjs";
+//#region src/signals/lib/battery.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+	vi.unstubAllGlobals();
+});
+describe("createBattery", () => {
+	it("returns unsupported=false when getBattery not present", () => {
+		vi.stubGlobal("navigator", {});
+		let b;
+		effectScope(() => {
+			b = createBattery();
+		});
+		globalExpect(b.supported()).toBe(false);
+	});
+	it("fetches battery info via getBattery", async () => {
+		const batteryMock = {
+			charging: true,
+			level: .8,
+			chargingTime: 3600,
+			dischargingTime: Infinity,
+			addEventListener: vi.fn(),
+			removeEventListener: vi.fn()
+		};
+		vi.stubGlobal("navigator", { getBattery: vi.fn().mockResolvedValue(batteryMock) });
+		let b;
+		effectScope(() => {
+			b = createBattery();
+		});
+		await new Promise((res) => setTimeout(res, 0));
+		globalExpect(b.charging()).toBe(true);
+		globalExpect(b.level()).toBe(.8);
+	});
+});
+//#endregion
+export {};

package/dist/signals/lib/before-unload.d.mts

@@ -0,0 +1,11 @@
+//#region src/signals/lib/before-unload.d.ts
+/**
+ * Registers a `beforeunload` handler that shows a native confirmation dialog
+ * when the user tries to leave the page.
+ *
+ * `message` can be a string or a reactive getter (re-evaluated on each event).
+ * Modern browsers ignore custom messages and show a generic prompt instead.
+ */
+declare function createBeforeUnload(message?: string | (() => string)): Disposable;
+//#endregion
+export { createBeforeUnload };

package/dist/signals/lib/before-unload.mjs

@@ -0,0 +1,20 @@
+import { createEventListener } from "./event-listener.mjs";
+//#region src/signals/lib/before-unload.ts
+/**
+* Registers a `beforeunload` handler that shows a native confirmation dialog
+* when the user tries to leave the page.
+*
+* `message` can be a string or a reactive getter (re-evaluated on each event).
+* Modern browsers ignore custom messages and show a generic prompt instead.
+*/
+function createBeforeUnload(message) {
+	const handler = (e) => {
+		const msg = typeof message === "function" ? message() : message;
+		e.preventDefault();
+		if (msg !== void 0) e.returnValue = msg;
+	};
+	const cleanup = createEventListener(window, "beforeunload", handler);
+	return { [Symbol.dispose]: cleanup };
+}
+//#endregion
+export { createBeforeUnload };

package/dist/signals/lib/before-unload.test.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/signals/lib/before-unload.test.mjs

@@ -0,0 +1,29 @@
+import { o as effectScope } from "../../signals-CLAPw8kk.mjs";
+import { a as describe, n as vi, o as it, r as afterEach, t as globalExpect } from "../../test.BmQO5GaM-CR2qjV1t.mjs";
+import { createBeforeUnload } from "./before-unload.mjs";
+//#region src/signals/lib/before-unload.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+});
+describe("createBeforeUnload", () => {
+	it("registers a beforeunload handler", () => {
+		const addSpy = vi.spyOn(window, "addEventListener");
+		effectScope(() => {
+			createBeforeUnload("Are you sure?");
+		});
+		globalExpect(addSpy).toHaveBeenCalledWith("beforeunload", globalExpect.any(Function));
+		addSpy.mockRestore();
+	});
+	it("removes the handler on Symbol.dispose", () => {
+		const removeSpy = vi.spyOn(window, "removeEventListener");
+		let bu;
+		effectScope(() => {
+			bu = createBeforeUnload();
+		});
+		bu[Symbol.dispose]();
+		globalExpect(removeSpy).toHaveBeenCalledWith("beforeunload", globalExpect.any(Function));
+		removeSpy.mockRestore();
+	});
+});
+//#endregion
+export {};