elements-kit 0.0.8 → 0.0.10

package/dist/signals/lib/search-params.mjs

@@ -0,0 +1,37 @@
+import { f as signal } from "../../signals-CLAPw8kk.mjs";
+import { createEventListener } from "./event-listener.mjs";
+//#region src/signals/lib/search-params.ts
+function readParams() {
+	return new URLSearchParams(typeof location !== "undefined" ? location.search : "");
+}
+/**
+* Returns reactive access to the URL's search params.  Writing via `set` /
+* `delete` updates both `location.search` and the reactive signal.
+*/
+function createSearchParams() {
+	const params = signal(readParams());
+	const onPopState = () => params(readParams());
+	const cleanup = createEventListener(window, "popstate", onPopState);
+	const get = (key) => params().get(key);
+	const set = (key, value) => {
+		const next = readParams();
+		next.set(key, value);
+		history.replaceState(null, "", `?${next.toString()}`);
+		params(next);
+	};
+	const del = (key) => {
+		const next = readParams();
+		next.delete(key);
+		const qs = next.toString();
+		history.replaceState(null, "", qs ? `?${qs}` : location.pathname);
+		params(next);
+	};
+	return Object.assign({
+		params,
+		get,
+		set,
+		delete: del
+	}, { [Symbol.dispose]: cleanup });
+}
+//#endregion
+export { createSearchParams };

package/dist/signals/lib/search-params.test.d.mts

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

package/dist/signals/lib/search-params.test.mjs

@@ -0,0 +1,56 @@
+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 { createSearchParams } from "./search-params.mjs";
+//#region src/signals/lib/search-params.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+	history.replaceState(null, "", location.pathname);
+});
+describe("createSearchParams", () => {
+	it("reads initial search params", () => {
+		let sp;
+		effectScope(() => {
+			sp = createSearchParams();
+		});
+		globalExpect(sp.params()).toBeInstanceOf(URLSearchParams);
+	});
+	it("set() updates a param", () => {
+		let sp;
+		effectScope(() => {
+			sp = createSearchParams();
+		});
+		sp.set("q", "hello");
+		globalExpect(sp.get("q")).toBe("hello");
+		globalExpect(sp.params().get("q")).toBe("hello");
+	});
+	it("delete() removes a param", () => {
+		let sp;
+		effectScope(() => {
+			sp = createSearchParams();
+		});
+		sp.set("q", "hello");
+		sp.delete("q");
+		globalExpect(sp.get("q")).toBeNull();
+	});
+	it("updates on popstate event", () => {
+		let sp;
+		effectScope(() => {
+			sp = createSearchParams();
+		});
+		history.replaceState(null, "", "?foo=bar");
+		window.dispatchEvent(new PopStateEvent("popstate"));
+		globalExpect(sp.get("foo")).toBe("bar");
+	});
+	it("stops reacting after Symbol.dispose", () => {
+		let sp;
+		effectScope(() => {
+			sp = createSearchParams();
+		});
+		sp[Symbol.dispose]();
+		history.replaceState(null, "", "?x=1");
+		window.dispatchEvent(new PopStateEvent("popstate"));
+		globalExpect(sp.get("x")).toBeNull();
+	});
+});
+//#endregion
+export {};

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

@@ -0,0 +1,18 @@
+import { t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/set.d.ts
+type ReactiveSetResult<T> = {
+  entries: Computed<ReadonlySet<T>>;
+  add(value: T): void;
+  remove(value: T): void;
+  toggle(value: T): void;
+  has(value: T): boolean;
+  clear(): void;
+  size: Computed<number>;
+};
+/**
+ * Reactive `Set` with mutation helpers.
+ */
+declare function createSet<T>(initial?: Set<T>): ReactiveSetResult<T>;
+//#endregion
+export { createSet };

package/dist/signals/lib/set.mjs

@@ -0,0 +1,38 @@
+import { f as signal } from "../../signals-CLAPw8kk.mjs";
+//#region src/signals/lib/set.ts
+/**
+* Reactive `Set` with mutation helpers.
+*/
+function createSet(initial) {
+	const s = signal(new Set(initial));
+	const add = (value) => {
+		const next = new Set(s());
+		next.add(value);
+		s(next);
+	};
+	const remove = (value) => {
+		const next = new Set(s());
+		next.delete(value);
+		s(next);
+	};
+	const toggle = (value) => {
+		const next = new Set(s());
+		if (next.has(value)) next.delete(value);
+		else next.add(value);
+		s(next);
+	};
+	const has = (value) => s().has(value);
+	const clear = () => s(/* @__PURE__ */ new Set());
+	const size = () => s().size;
+	return {
+		entries: s,
+		add,
+		remove,
+		toggle,
+		has,
+		clear,
+		size
+	};
+}
+//#endregion
+export { createSet };

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

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

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

@@ -0,0 +1,70 @@
+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 { createSet } from "./set.mjs";
+//#region src/signals/lib/set.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+});
+describe("createSet", () => {
+	it("starts empty by default", () => {
+		let s;
+		effectScope(() => {
+			s = createSet();
+		});
+		globalExpect(s.entries().size).toBe(0);
+		globalExpect(s.size()).toBe(0);
+	});
+	it("initializes from a Set", () => {
+		let s;
+		effectScope(() => {
+			s = createSet(new Set([
+				1,
+				2,
+				3
+			]));
+		});
+		globalExpect(s.has(2)).toBe(true);
+		globalExpect(s.size()).toBe(3);
+	});
+	it("add inserts a value", () => {
+		let s;
+		effectScope(() => {
+			s = createSet();
+		});
+		s.add(5);
+		globalExpect(s.has(5)).toBe(true);
+	});
+	it("remove deletes a value", () => {
+		let s;
+		effectScope(() => {
+			s = createSet(new Set([1, 2]));
+		});
+		s.remove(1);
+		globalExpect(s.has(1)).toBe(false);
+		globalExpect(s.size()).toBe(1);
+	});
+	it("toggle adds if absent, removes if present", () => {
+		let s;
+		effectScope(() => {
+			s = createSet();
+		});
+		s.toggle(7);
+		globalExpect(s.has(7)).toBe(true);
+		s.toggle(7);
+		globalExpect(s.has(7)).toBe(false);
+	});
+	it("clear empties the set", () => {
+		let s;
+		effectScope(() => {
+			s = createSet(new Set([
+				1,
+				2,
+				3
+			]));
+		});
+		s.clear();
+		globalExpect(s.size()).toBe(0);
+	});
+});
+//#endregion
+export {};

package/dist/signals/lib/start-typing.d.mts

@@ -0,0 +1,9 @@
+//#region src/signals/lib/start-typing.d.ts
+/**
+ * Fires `handler` once whenever the user starts typing (presses a non-modifier
+ * key on the document).  The handler is not called again until the user stops
+ * typing and then starts again (debounced by a 1 s idle window).
+ */
+declare function createStartTyping(handler: () => void, idleMs?: number): Disposable;
+//#endregion
+export { createStartTyping };

package/dist/signals/lib/start-typing.mjs

@@ -0,0 +1,39 @@
+import { d as onCleanup } from "../../signals-CLAPw8kk.mjs";
+import { createEventListener } from "./event-listener.mjs";
+//#region src/signals/lib/start-typing.ts
+const TYPING_KEYS = new Set([
+	"Meta",
+	"Alt",
+	"Control",
+	"Shift",
+	"CapsLock",
+	"Tab"
+]);
+/**
+* Fires `handler` once whenever the user starts typing (presses a non-modifier
+* key on the document).  The handler is not called again until the user stops
+* typing and then starts again (debounced by a 1 s idle window).
+*/
+function createStartTyping(handler, idleMs = 1e3) {
+	let timer;
+	let isTyping = false;
+	const onKeyDown = (e) => {
+		if (TYPING_KEYS.has(e.key)) return;
+		if (!isTyping) {
+			isTyping = true;
+			handler();
+		}
+		clearTimeout(timer);
+		timer = setTimeout(() => {
+			isTyping = false;
+		}, idleMs);
+	};
+	const removeListener = createEventListener(document, "keydown", onKeyDown);
+	onCleanup(() => clearTimeout(timer));
+	return { [Symbol.dispose]: () => {
+		clearTimeout(timer);
+		removeListener();
+	} };
+}
+//#endregion
+export { createStartTyping };

package/dist/signals/lib/start-typing.test.d.mts

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

package/dist/signals/lib/start-typing.test.mjs

@@ -0,0 +1,64 @@
+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 { createStartTyping } from "./start-typing.mjs";
+//#region src/signals/lib/start-typing.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+	vi.useRealTimers();
+});
+describe("createStartTyping", () => {
+	it("calls handler on first keydown", () => {
+		vi.useFakeTimers();
+		const handler = vi.fn();
+		effectScope(() => {
+			createStartTyping(handler, 1e3);
+		});
+		document.dispatchEvent(new KeyboardEvent("keydown", { key: "a" }));
+		globalExpect(handler).toHaveBeenCalledOnce();
+	});
+	it("does not call handler again while still typing", () => {
+		vi.useFakeTimers();
+		const handler = vi.fn();
+		effectScope(() => {
+			createStartTyping(handler, 1e3);
+		});
+		document.dispatchEvent(new KeyboardEvent("keydown", { key: "a" }));
+		document.dispatchEvent(new KeyboardEvent("keydown", { key: "b" }));
+		document.dispatchEvent(new KeyboardEvent("keydown", { key: "c" }));
+		globalExpect(handler).toHaveBeenCalledOnce();
+	});
+	it("calls handler again after idle period", () => {
+		vi.useFakeTimers();
+		const handler = vi.fn();
+		effectScope(() => {
+			createStartTyping(handler, 1e3);
+		});
+		document.dispatchEvent(new KeyboardEvent("keydown", { key: "a" }));
+		vi.advanceTimersByTime(1100);
+		document.dispatchEvent(new KeyboardEvent("keydown", { key: "b" }));
+		globalExpect(handler).toHaveBeenCalledTimes(2);
+	});
+	it("ignores modifier keys", () => {
+		vi.useFakeTimers();
+		const handler = vi.fn();
+		effectScope(() => {
+			createStartTyping(handler, 1e3);
+		});
+		document.dispatchEvent(new KeyboardEvent("keydown", { key: "Shift" }));
+		document.dispatchEvent(new KeyboardEvent("keydown", { key: "Control" }));
+		globalExpect(handler).not.toHaveBeenCalled();
+	});
+	it("stops on Symbol.dispose", () => {
+		vi.useFakeTimers();
+		const handler = vi.fn();
+		let st;
+		effectScope(() => {
+			st = createStartTyping(handler, 1e3);
+		});
+		st[Symbol.dispose]();
+		document.dispatchEvent(new KeyboardEvent("keydown", { key: "a" }));
+		globalExpect(handler).not.toHaveBeenCalled();
+	});
+});
+//#endregion
+export {};

package/dist/signals/lib/state-history.d.mts

@@ -0,0 +1,21 @@
+import { t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/state-history.d.ts
+type StateHistoryResult<T> = {
+  history: Computed<T[]>;
+  index: Computed<number>;
+  canUndo: Computed<boolean>;
+  canRedo: Computed<boolean>;
+  undo(): void;
+  redo(): void;
+  clear(): void;
+};
+/**
+ * Tracks the history of a reactive getter, providing `undo` and `redo`.
+ *
+ * @param getter - A reactive getter whose value is tracked.
+ * @param capacity - Maximum number of history entries (default: 100).
+ */
+declare function createStateHistory<T>(getter: () => T, capacity?: number): StateHistoryResult<T>;
+//#endregion
+export { createStateHistory };

package/dist/signals/lib/state-history.mjs

@@ -0,0 +1,61 @@
+import { a as effect, f as signal } from "../../signals-CLAPw8kk.mjs";
+//#region src/signals/lib/state-history.ts
+/**
+* Tracks the history of a reactive getter, providing `undo` and `redo`.
+*
+* @param getter - A reactive getter whose value is tracked.
+* @param capacity - Maximum number of history entries (default: 100).
+*/
+function createStateHistory(getter, capacity = 100) {
+	const history = signal([getter()]);
+	const index = signal(0);
+	let paused = false;
+	let firstRun = true;
+	effect(() => {
+		const next = getter();
+		if (paused) return;
+		if (firstRun) {
+			firstRun = false;
+			return;
+		}
+		const hist = history();
+		const idx = index();
+		const trimmed = hist.slice(0, idx + 1);
+		trimmed.push(next);
+		if (trimmed.length > capacity) trimmed.shift();
+		history(trimmed);
+		index(trimmed.length - 1);
+	});
+	const canUndo = () => index() > 0;
+	const canRedo = () => index() < history().length - 1;
+	const undo = () => {
+		if (!canUndo()) return;
+		paused = true;
+		index(index() - 1);
+		paused = false;
+	};
+	const redo = () => {
+		if (!canRedo()) return;
+		paused = true;
+		index(index() + 1);
+		paused = false;
+	};
+	const clear = () => {
+		const current = getter();
+		paused = true;
+		history([current]);
+		index(0);
+		paused = false;
+	};
+	return {
+		history,
+		index,
+		canUndo,
+		canRedo,
+		undo,
+		redo,
+		clear
+	};
+}
+//#endregion
+export { createStateHistory };

package/dist/signals/lib/state-history.test.d.mts

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

package/dist/signals/lib/state-history.test.mjs

@@ -0,0 +1,106 @@
+import { f as signal, 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 { createStateHistory } from "./state-history.mjs";
+//#region src/signals/lib/state-history.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+});
+describe("createStateHistory", () => {
+	it("starts with the current getter value in history", () => {
+		const s = signal(0);
+		let h;
+		effectScope(() => {
+			h = createStateHistory(() => s());
+		});
+		globalExpect(h.history()).toEqual([0]);
+		globalExpect(h.index()).toBe(0);
+	});
+	it("records new values", () => {
+		const s = signal(0);
+		let h;
+		effectScope(() => {
+			h = createStateHistory(() => s());
+		});
+		s(1);
+		s(2);
+		globalExpect(h.history()).toEqual([
+			0,
+			1,
+			2
+		]);
+		globalExpect(h.index()).toBe(2);
+	});
+	it("canUndo is false initially", () => {
+		const s = signal(0);
+		let h;
+		effectScope(() => {
+			h = createStateHistory(() => s());
+		});
+		globalExpect(h.canUndo()).toBe(false);
+	});
+	it("canUndo is true after a change", () => {
+		const s = signal(0);
+		let h;
+		effectScope(() => {
+			h = createStateHistory(() => s());
+		});
+		s(1);
+		globalExpect(h.canUndo()).toBe(true);
+	});
+	it("undo moves the index back", () => {
+		const s = signal(0);
+		let h;
+		effectScope(() => {
+			h = createStateHistory(() => s());
+		});
+		s(1);
+		s(2);
+		h.undo();
+		globalExpect(h.index()).toBe(1);
+		globalExpect(h.canRedo()).toBe(true);
+	});
+	it("redo moves the index forward", () => {
+		const s = signal(0);
+		let h;
+		effectScope(() => {
+			h = createStateHistory(() => s());
+		});
+		s(1);
+		s(2);
+		h.undo();
+		h.redo();
+		globalExpect(h.index()).toBe(2);
+		globalExpect(h.canRedo()).toBe(false);
+	});
+	it("new change after undo drops the future", () => {
+		const s = signal(0);
+		let h;
+		effectScope(() => {
+			h = createStateHistory(() => s());
+		});
+		s(1);
+		s(2);
+		h.undo();
+		s(3);
+		globalExpect(h.history()).toEqual([
+			0,
+			1,
+			3
+		]);
+		globalExpect(h.canRedo()).toBe(false);
+	});
+	it("clear resets history to the current value", () => {
+		const s = signal(0);
+		let h;
+		effectScope(() => {
+			h = createStateHistory(() => s());
+		});
+		s(1);
+		s(2);
+		h.clear();
+		globalExpect(h.history()).toEqual([2]);
+		globalExpect(h.index()).toBe(0);
+	});
+});
+//#endregion
+export {};

package/dist/signals/lib/state-validator.d.mts

@@ -0,0 +1,16 @@
+import { t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/state-validator.d.ts
+type StateValidatorResult<E> = {
+  errors: Computed<E | null>;
+  isValid: Computed<boolean>;
+};
+/**
+ * Runs `validator` reactively against a getter's value and exposes the result
+ * as `errors` and `isValid` computeds.
+ *
+ * Return `null` from `validator` to indicate no error.
+ */
+declare function createStateValidator<T, E>(getter: () => T, validator: (value: T) => E | null): StateValidatorResult<E>;
+//#endregion
+export { createStateValidator };

package/dist/signals/lib/state-validator.mjs

@@ -0,0 +1,21 @@
+import { a as effect, f as signal } from "../../signals-CLAPw8kk.mjs";
+//#region src/signals/lib/state-validator.ts
+/**
+* Runs `validator` reactively against a getter's value and exposes the result
+* as `errors` and `isValid` computeds.
+*
+* Return `null` from `validator` to indicate no error.
+*/
+function createStateValidator(getter, validator) {
+	const errors = signal(null);
+	effect(() => {
+		errors(validator(getter()));
+	});
+	const isValid = () => errors() === null;
+	return {
+		errors,
+		isValid
+	};
+}
+//#endregion
+export { createStateValidator };

package/dist/signals/lib/state-validator.test.d.mts

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

package/dist/signals/lib/state-validator.test.mjs

@@ -0,0 +1,41 @@
+import { f as signal, 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 { createStateValidator } from "./state-validator.mjs";
+//#region src/signals/lib/state-validator.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+});
+describe("createStateValidator", () => {
+	it("starts with validator result of the initial value", () => {
+		const s = signal("");
+		let v;
+		effectScope(() => {
+			v = createStateValidator(() => s(), (value) => value.length < 3 ? "Too short" : null);
+		});
+		globalExpect(v.errors()).toBe("Too short");
+		globalExpect(v.isValid()).toBe(false);
+	});
+	it("becomes valid when constraint is met", () => {
+		const s = signal("");
+		let v;
+		effectScope(() => {
+			v = createStateValidator(() => s(), (value) => value.length < 3 ? "Too short" : null);
+		});
+		s("hello");
+		globalExpect(v.errors()).toBeNull();
+		globalExpect(v.isValid()).toBe(true);
+	});
+	it("re-validates when the source changes", () => {
+		const s = signal(5);
+		let v;
+		effectScope(() => {
+			v = createStateValidator(() => s(), (n) => n > 10 ? "Too big" : null);
+		});
+		globalExpect(v.isValid()).toBe(true);
+		s(15);
+		globalExpect(v.errors()).toBe("Too big");
+		globalExpect(v.isValid()).toBe(false);
+	});
+});
+//#endregion
+export {};

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

@@ -0,0 +1,13 @@
+import { t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/throttled.d.ts
+/**
+ * Returns a `Computed` that mirrors `getter` but updates at most once per
+ * `interval` milliseconds.  A trailing-edge update is scheduled so the final
+ * value is never lost.
+ *
+ * The initial value is read synchronously.
+ */
+declare function createThrottled<T>(getter: () => T, interval: number): Computed<T>;
+//#endregion
+export { createThrottled };

package/dist/signals/lib/throttled.mjs

@@ -0,0 +1,45 @@
+import { a as effect, d as onCleanup, f as signal } from "../../signals-CLAPw8kk.mjs";
+//#region src/signals/lib/throttled.ts
+/**
+* Returns a `Computed` that mirrors `getter` but updates at most once per
+* `interval` milliseconds.  A trailing-edge update is scheduled so the final
+* value is never lost.
+*
+* The initial value is read synchronously.
+*/
+function createThrottled(getter, interval) {
+	const s = signal(getter());
+	let lastRun = -Infinity;
+	let trailingTimer;
+	let firstRun = true;
+	effect(() => {
+		const latest = getter();
+		if (firstRun) {
+			firstRun = false;
+			return;
+		}
+		const now = Date.now();
+		const elapsed = now - lastRun;
+		if (trailingTimer !== void 0) {
+			clearTimeout(trailingTimer);
+			trailingTimer = void 0;
+		}
+		if (elapsed >= interval) {
+			lastRun = now;
+			s(latest);
+		} else {
+			trailingTimer = setTimeout(() => {
+				lastRun = Date.now();
+				trailingTimer = void 0;
+				s(latest);
+			}, interval - elapsed);
+			onCleanup(() => {
+				clearTimeout(trailingTimer);
+				trailingTimer = void 0;
+			});
+		}
+	});
+	return s;
+}
+//#endregion
+export { createThrottled };

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

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