elements-kit 0.0.8 → 0.0.10

package/dist/signals/lib/is-in-viewport.test.mjs

@@ -0,0 +1,74 @@
+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 { createIsInViewport } from "./is-in-viewport.mjs";
+//#region src/signals/lib/is-in-viewport.test.ts
+afterEach(() => {
+	vi.unstubAllGlobals();
+});
+function mockIntersectionObserver() {
+	let observerCallback;
+	const observe = vi.fn();
+	const disconnect = vi.fn();
+	const unobserve = vi.fn();
+	vi.stubGlobal("IntersectionObserver", function MockIO(cb) {
+		observerCallback = cb;
+		return {
+			observe,
+			disconnect,
+			unobserve,
+			root: null,
+			rootMargin: "",
+			thresholds: []
+		};
+	});
+	return {
+		fire: (isIntersecting) => {
+			observerCallback([{ isIntersecting }], {});
+		},
+		disconnect
+	};
+}
+describe("createIsInViewport", () => {
+	it("starts as false", () => {
+		const { fire: _fire } = mockIntersectionObserver();
+		const el = document.createElement("div");
+		let visible;
+		effectScope(() => {
+			visible = createIsInViewport(el);
+		});
+		globalExpect(visible()).toBe(false);
+	});
+	it("becomes true when intersection fires with isIntersecting=true", () => {
+		const { fire } = mockIntersectionObserver();
+		const el = document.createElement("div");
+		let visible;
+		effectScope(() => {
+			visible = createIsInViewport(el);
+		});
+		fire(true);
+		globalExpect(visible()).toBe(true);
+	});
+	it("becomes false when intersection fires with isIntersecting=false", () => {
+		const { fire } = mockIntersectionObserver();
+		const el = document.createElement("div");
+		let visible;
+		effectScope(() => {
+			visible = createIsInViewport(el);
+		});
+		fire(true);
+		fire(false);
+		globalExpect(visible()).toBe(false);
+	});
+	it("disconnects on Symbol.dispose", () => {
+		const { disconnect } = mockIntersectionObserver();
+		const el = document.createElement("div");
+		let visible;
+		effectScope(() => {
+			visible = createIsInViewport(el);
+		});
+		visible[Symbol.dispose]();
+		globalExpect(disconnect).toHaveBeenCalledOnce();
+	});
+});
+//#endregion
+export {};

package/dist/signals/lib/key-press.d.mts

@@ -0,0 +1,13 @@
+import { t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/key-press.d.ts
+type KeyPressResult = {
+  pressed: Computed<boolean>;
+} & Disposable;
+/**
+ * Returns a reactive boolean that is `true` while the given keyboard `key`
+ * is held down.
+ */
+declare function createKeyPress(key: string): KeyPressResult;
+//#endregion
+export { createKeyPress };

package/dist/signals/lib/key-press.mjs

@@ -0,0 +1,25 @@
+import { f as signal } from "../../signals-CLAPw8kk.mjs";
+import { createEventListener } from "./event-listener.mjs";
+//#region src/signals/lib/key-press.ts
+/**
+* Returns a reactive boolean that is `true` while the given keyboard `key`
+* is held down.
+*/
+function createKeyPress(key) {
+	const pressed = signal(false);
+	const onDown = (e) => {
+		if (e.key === key) pressed(true);
+	};
+	const onUp = (e) => {
+		if (e.key === key) pressed(false);
+	};
+	const r1 = createEventListener(window, "keydown", onDown);
+	const r2 = createEventListener(window, "keyup", onUp);
+	const cleanup = () => {
+		r1();
+		r2();
+	};
+	return Object.assign({ pressed }, { [Symbol.dispose]: cleanup });
+}
+//#endregion
+export { createKeyPress };

package/dist/signals/lib/key-press.test.d.mts

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

package/dist/signals/lib/key-press.test.mjs

@@ -0,0 +1,52 @@
+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 { createKeyPress } from "./key-press.mjs";
+//#region src/signals/lib/key-press.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+});
+describe("createKeyPress", () => {
+	it("starts as false", () => {
+		let k;
+		effectScope(() => {
+			k = createKeyPress("a");
+		});
+		globalExpect(k.pressed()).toBe(false);
+	});
+	it("becomes true on keydown", () => {
+		let k;
+		effectScope(() => {
+			k = createKeyPress("a");
+		});
+		window.dispatchEvent(new KeyboardEvent("keydown", { key: "a" }));
+		globalExpect(k.pressed()).toBe(true);
+	});
+	it("becomes false on keyup", () => {
+		let k;
+		effectScope(() => {
+			k = createKeyPress("a");
+		});
+		window.dispatchEvent(new KeyboardEvent("keydown", { key: "a" }));
+		window.dispatchEvent(new KeyboardEvent("keyup", { key: "a" }));
+		globalExpect(k.pressed()).toBe(false);
+	});
+	it("does not react to different keys", () => {
+		let k;
+		effectScope(() => {
+			k = createKeyPress("a");
+		});
+		window.dispatchEvent(new KeyboardEvent("keydown", { key: "b" }));
+		globalExpect(k.pressed()).toBe(false);
+	});
+	it("stops reacting after Symbol.dispose", () => {
+		let k;
+		effectScope(() => {
+			k = createKeyPress("a");
+		});
+		k[Symbol.dispose]();
+		window.dispatchEvent(new KeyboardEvent("keydown", { key: "a" }));
+		globalExpect(k.pressed()).toBe(false);
+	});
+});
+//#endregion
+export {};

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

@@ -0,0 +1,19 @@
+import { t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/list.d.ts
+type ListResult<T> = {
+  items: Computed<readonly T[]>;
+  push(...items: T[]): void;
+  pop(): T | undefined;
+  remove(index: number): void;
+  filter(fn: (item: T, index: number) => boolean): void;
+  set(items: T[]): void;
+  clear(): void;
+  size: Computed<number>;
+};
+/**
+ * Reactive array with mutation helpers.
+ */
+declare function createList<T>(initial?: T[]): ListResult<T>;
+//#endregion
+export { createList };

package/dist/signals/lib/list.mjs

@@ -0,0 +1,36 @@
+import { f as signal } from "../../signals-CLAPw8kk.mjs";
+//#region src/signals/lib/list.ts
+/**
+* Reactive array with mutation helpers.
+*/
+function createList(initial = []) {
+	const items = signal([...initial]);
+	const push = (...newItems) => items([...items(), ...newItems]);
+	const pop = () => {
+		const arr = [...items()];
+		const last = arr.pop();
+		items(arr);
+		return last;
+	};
+	const remove = (index) => {
+		const arr = [...items()];
+		arr.splice(index, 1);
+		items(arr);
+	};
+	const filter = (fn) => items(items().filter(fn));
+	const set = (next) => items([...next]);
+	const clear = () => items([]);
+	const size = () => items().length;
+	return {
+		items,
+		push,
+		pop,
+		remove,
+		filter,
+		set,
+		clear,
+		size
+	};
+}
+//#endregion
+export { createList };

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

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

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

@@ -0,0 +1,104 @@
+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 { createList } from "./list.mjs";
+//#region src/signals/lib/list.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+});
+describe("createList", () => {
+	it("starts empty by default", () => {
+		let l;
+		effectScope(() => {
+			l = createList();
+		});
+		globalExpect(l.items()).toEqual([]);
+		globalExpect(l.size()).toBe(0);
+	});
+	it("starts with initial items", () => {
+		let l;
+		effectScope(() => {
+			l = createList([
+				1,
+				2,
+				3
+			]);
+		});
+		globalExpect(l.items()).toEqual([
+			1,
+			2,
+			3
+		]);
+	});
+	it("push adds items", () => {
+		let l;
+		effectScope(() => {
+			l = createList();
+		});
+		l.push(1, 2);
+		globalExpect(l.items()).toEqual([1, 2]);
+	});
+	it("pop removes and returns the last item", () => {
+		let l;
+		effectScope(() => {
+			l = createList([
+				1,
+				2,
+				3
+			]);
+		});
+		globalExpect(l.pop()).toBe(3);
+		globalExpect(l.items()).toEqual([1, 2]);
+	});
+	it("remove removes by index", () => {
+		let l;
+		effectScope(() => {
+			l = createList([
+				1,
+				2,
+				3
+			]);
+		});
+		l.remove(1);
+		globalExpect(l.items()).toEqual([1, 3]);
+	});
+	it("filter keeps matching items", () => {
+		let l;
+		effectScope(() => {
+			l = createList([
+				1,
+				2,
+				3,
+				4
+			]);
+		});
+		l.filter((n) => n % 2 === 0);
+		globalExpect(l.items()).toEqual([2, 4]);
+	});
+	it("set replaces all items", () => {
+		let l;
+		effectScope(() => {
+			l = createList([
+				1,
+				2,
+				3
+			]);
+		});
+		l.set([10, 20]);
+		globalExpect(l.items()).toEqual([10, 20]);
+	});
+	it("clear empties the list", () => {
+		let l;
+		effectScope(() => {
+			l = createList([
+				1,
+				2,
+				3
+			]);
+		});
+		l.clear();
+		globalExpect(l.items()).toEqual([]);
+		globalExpect(l.size()).toBe(0);
+	});
+});
+//#endregion
+export {};

package/dist/signals/lib/lock-body-scroll.d.mts

@@ -0,0 +1,8 @@
+//#region src/signals/lib/lock-body-scroll.d.ts
+/**
+ * Prevents the document body from scrolling while the returned scope is
+ * active.  Restores the original `overflow` value on cleanup.
+ */
+declare function createLockBodyScroll(): Disposable;
+//#endregion
+export { createLockBodyScroll };

package/dist/signals/lib/lock-body-scroll.mjs

@@ -0,0 +1,17 @@
+import { d as onCleanup } from "../../signals-CLAPw8kk.mjs";
+//#region src/signals/lib/lock-body-scroll.ts
+/**
+* Prevents the document body from scrolling while the returned scope is
+* active.  Restores the original `overflow` value on cleanup.
+*/
+function createLockBodyScroll() {
+	const original = document.body.style.overflow;
+	document.body.style.overflow = "hidden";
+	const cleanup = () => {
+		document.body.style.overflow = original;
+	};
+	onCleanup(cleanup);
+	return { [Symbol.dispose]: cleanup };
+}
+//#endregion
+export { createLockBodyScroll };

package/dist/signals/lib/lock-body-scroll.test.d.mts

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

package/dist/signals/lib/lock-body-scroll.test.mjs

@@ -0,0 +1,37 @@
+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 { createLockBodyScroll } from "./lock-body-scroll.mjs";
+//#region src/signals/lib/lock-body-scroll.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+	document.body.style.overflow = "";
+});
+describe("createLockBodyScroll", () => {
+	it("sets body overflow to hidden", () => {
+		effectScope(() => {
+			createLockBodyScroll();
+		});
+		globalExpect(document.body.style.overflow).toBe("hidden");
+	});
+	it("restores original overflow on Symbol.dispose", () => {
+		document.body.style.overflow = "scroll";
+		let lock;
+		effectScope(() => {
+			lock = createLockBodyScroll();
+		});
+		globalExpect(document.body.style.overflow).toBe("hidden");
+		lock[Symbol.dispose]();
+		globalExpect(document.body.style.overflow).toBe("scroll");
+	});
+	it("restores empty overflow when no prior style", () => {
+		document.body.style.overflow = "";
+		let lock;
+		effectScope(() => {
+			lock = createLockBodyScroll();
+		});
+		lock[Symbol.dispose]();
+		globalExpect(document.body.style.overflow).toBe("");
+	});
+});
+//#endregion
+export {};

package/dist/signals/lib/long-press.d.mts

@@ -0,0 +1,10 @@
+//#region src/signals/lib/long-press.d.ts
+/**
+ * Fires `handler` when a pointer is held over `target` for at least `delay`
+ * milliseconds (default: 500 ms).
+ */
+declare function createLongPress(target: Element | (() => Element | null), handler: (e: PointerEvent) => void, options?: {
+  delay?: number;
+}): Disposable;
+//#endregion
+export { createLongPress };

package/dist/signals/lib/long-press.mjs

@@ -0,0 +1,29 @@
+import { createEventListener } from "./event-listener.mjs";
+//#region src/signals/lib/long-press.ts
+/**
+* Fires `handler` when a pointer is held over `target` for at least `delay`
+* milliseconds (default: 500 ms).
+*/
+function createLongPress(target, handler, options = {}) {
+	const { delay = 500 } = options;
+	const el = typeof target === "function" ? target() : target;
+	let timer;
+	const onPointerDown = (e) => {
+		timer = setTimeout(() => handler(e), delay);
+	};
+	const cancel = () => clearTimeout(timer);
+	const cleanups = [];
+	if (el) {
+		cleanups.push(createEventListener(el, "pointerdown", onPointerDown));
+		cleanups.push(createEventListener(el, "pointerup", cancel));
+		cleanups.push(createEventListener(el, "pointerleave", cancel));
+		cleanups.push(createEventListener(el, "pointermove", cancel));
+	}
+	const cleanup = () => {
+		clearTimeout(timer);
+		cleanups.forEach((fn) => fn());
+	};
+	return { [Symbol.dispose]: cleanup };
+}
+//#endregion
+export { createLongPress };

package/dist/signals/lib/long-press.test.d.mts

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

package/dist/signals/lib/long-press.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 { createLongPress } from "./long-press.mjs";
+//#region src/signals/lib/long-press.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+	vi.useRealTimers();
+});
+describe("createLongPress", () => {
+	it("does not fire handler on short press", () => {
+		vi.useFakeTimers();
+		const el = document.createElement("button");
+		document.body.appendChild(el);
+		const handler = vi.fn();
+		effectScope(() => {
+			createLongPress(el, handler, { delay: 500 });
+		});
+		el.dispatchEvent(new PointerEvent("pointerdown"));
+		vi.advanceTimersByTime(200);
+		el.dispatchEvent(new PointerEvent("pointerup"));
+		vi.advanceTimersByTime(500);
+		globalExpect(handler).not.toHaveBeenCalled();
+	});
+	it("fires handler after delay", () => {
+		vi.useFakeTimers();
+		const el = document.createElement("button");
+		document.body.appendChild(el);
+		const handler = vi.fn();
+		effectScope(() => {
+			createLongPress(el, handler, { delay: 500 });
+		});
+		el.dispatchEvent(new PointerEvent("pointerdown"));
+		vi.advanceTimersByTime(600);
+		globalExpect(handler).toHaveBeenCalledOnce();
+	});
+	it("cancels when pointer moves", () => {
+		vi.useFakeTimers();
+		const el = document.createElement("button");
+		document.body.appendChild(el);
+		const handler = vi.fn();
+		effectScope(() => {
+			createLongPress(el, handler, { delay: 500 });
+		});
+		el.dispatchEvent(new PointerEvent("pointerdown"));
+		vi.advanceTimersByTime(200);
+		el.dispatchEvent(new PointerEvent("pointermove"));
+		vi.advanceTimersByTime(500);
+		globalExpect(handler).not.toHaveBeenCalled();
+	});
+});
+//#endregion
+export {};

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

@@ -0,0 +1,18 @@
+import { t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/map.d.ts
+type ReactiveMapResult<K, V> = {
+  entries: Computed<ReadonlyMap<K, V>>;
+  get(key: K): V | undefined;
+  set(key: K, value: V): void;
+  delete(key: K): void;
+  has(key: K): boolean;
+  clear(): void;
+  size: Computed<number>;
+};
+/**
+ * Reactive `Map` with mutation helpers.
+ */
+declare function createMap<K, V>(initial?: Map<K, V>): ReactiveMapResult<K, V>;
+//#endregion
+export { createMap };

package/dist/signals/lib/map.mjs

@@ -0,0 +1,33 @@
+import { f as signal } from "../../signals-CLAPw8kk.mjs";
+//#region src/signals/lib/map.ts
+/**
+* Reactive `Map` with mutation helpers.
+*/
+function createMap(initial) {
+	const s = signal(new Map(initial));
+	const get = (key) => s().get(key);
+	const set = (key, value) => {
+		const next = new Map(s());
+		next.set(key, value);
+		s(next);
+	};
+	const del = (key) => {
+		const next = new Map(s());
+		next.delete(key);
+		s(next);
+	};
+	const has = (key) => s().has(key);
+	const clear = () => s(/* @__PURE__ */ new Map());
+	const size = () => s().size;
+	return {
+		entries: s,
+		get,
+		set,
+		delete: del,
+		has,
+		clear,
+		size
+	};
+}
+//#endregion
+export { createMap };

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

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

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

@@ -0,0 +1,60 @@
+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 { createMap } from "./map.mjs";
+//#region src/signals/lib/map.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+});
+describe("createMap", () => {
+	it("starts empty by default", () => {
+		let m;
+		effectScope(() => {
+			m = createMap();
+		});
+		globalExpect(m.entries().size).toBe(0);
+		globalExpect(m.size()).toBe(0);
+	});
+	it("initializes from a Map", () => {
+		let m;
+		effectScope(() => {
+			m = createMap(new Map([["a", 1]]));
+		});
+		globalExpect(m.get("a")).toBe(1);
+	});
+	it("set adds an entry", () => {
+		let m;
+		effectScope(() => {
+			m = createMap();
+		});
+		m.set("x", 42);
+		globalExpect(m.get("x")).toBe(42);
+		globalExpect(m.size()).toBe(1);
+	});
+	it("delete removes an entry", () => {
+		let m;
+		effectScope(() => {
+			m = createMap(new Map([["a", 1], ["b", 2]]));
+		});
+		m.delete("a");
+		globalExpect(m.has("a")).toBe(false);
+		globalExpect(m.size()).toBe(1);
+	});
+	it("has returns correct boolean", () => {
+		let m;
+		effectScope(() => {
+			m = createMap(new Map([["a", 1]]));
+		});
+		globalExpect(m.has("a")).toBe(true);
+		globalExpect(m.has("z")).toBe(false);
+	});
+	it("clear empties the map", () => {
+		let m;
+		effectScope(() => {
+			m = createMap(new Map([["a", 1], ["b", 2]]));
+		});
+		m.clear();
+		globalExpect(m.size()).toBe(0);
+	});
+});
+//#endregion
+export {};

package/dist/signals/lib/media-devices.d.mts

@@ -0,0 +1,10 @@
+import { t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/media-devices.d.ts
+/**
+ * Returns a reactive list of available media devices, refreshed whenever
+ * devices are added or removed.
+ */
+declare function createMediaDevices(): Computed<MediaDeviceInfo[]> & Disposable;
+//#endregion
+export { createMediaDevices };

package/dist/signals/lib/media-devices.mjs

@@ -0,0 +1,18 @@
+import { f as signal } from "../../signals-CLAPw8kk.mjs";
+import { createEventListener } from "./event-listener.mjs";
+//#region src/signals/lib/media-devices.ts
+/**
+* Returns a reactive list of available media devices, refreshed whenever
+* devices are added or removed.
+*/
+function createMediaDevices() {
+	const devices = signal([]);
+	const refresh = () => {
+		navigator.mediaDevices.enumerateDevices().then((list) => devices(list));
+	};
+	refresh();
+	const cleanup = createEventListener(navigator.mediaDevices, "devicechange", refresh);
+	return Object.assign(devices, { [Symbol.dispose]: cleanup });
+}
+//#endregion
+export { createMediaDevices };

package/dist/signals/lib/media-devices.test.d.mts

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