elements-kit 0.18.2 → 0.20.0

package/dist/utilities/active-element.test.d.mts

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

package/dist/utilities/active-element.test.mjs

@@ -1,25 +0,0 @@
-import { f as it, l as describe } from "../benchmark.CX_oY03V-CSLAXL5f.mjs";
-import { t as globalExpect } from "../test.BmQO5GaM-Ddz9cDxc.mjs";
-import { activeElement } from "./active-element.mjs";
-//#region src/utilities/active-element.test.ts
-describe("activeElement (singleton)", () => {
-	it("returns a computed that reads the current activeElement", () => {
-		globalExpect(activeElement()).toBe(document.activeElement);
-	});
-	it("updates when focus changes", () => {
-		const input = document.createElement("input");
-		document.body.appendChild(input);
-		input.focus();
-		globalExpect(activeElement()).toBe(input);
-		document.body.removeChild(input);
-	});
-	it("remains reactive after scope disposal", () => {
-		const input = document.createElement("input");
-		document.body.appendChild(input);
-		input.focus();
-		globalExpect(activeElement()).toBe(input);
-		document.body.removeChild(input);
-	});
-});
-//#endregion
-export {};

package/dist/utilities/async.test.d.mts

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

package/dist/utilities/async.test.mjs

@@ -1,275 +0,0 @@
-import { m as signal, p as onCleanup, s as effect } from "../lib-Dkc7cV5F.mjs";
-import "../signals/index.mjs";
-import { f as it, l as describe } from "../benchmark.CX_oY03V-CSLAXL5f.mjs";
-import { n as vi, t as globalExpect } from "../test.BmQO5GaM-Ddz9cDxc.mjs";
-import { Async, async } from "./async.mjs";
-import { createInterval } from "./interval.mjs";
-//#region src/utilities/async.test.ts
-function deferred() {
-	let resolve;
-	let reject;
-	return {
-		promise: new Promise((res, rej) => {
-			resolve = res;
-			reject = rej;
-		}),
-		resolve,
-		reject
-	};
-}
-describe("Async", () => {
-	it("is reactive as a computed signal (effect)", async () => {
-		const op = async((x) => Promise.resolve(x * 2));
-		const values = [];
-		const stop = effect(() => {
-			values.push(op());
-		});
-		op.run(2);
-		await op;
-		op.run(3);
-		await op;
-		stop();
-		globalExpect(values).toContain(void 0);
-		globalExpect(values).toContain(4);
-		globalExpect(values).toContain(6);
-		globalExpect(values.at(-1)).toBe(6);
-	});
-	it("is callable as a signal and returns the current result", async () => {
-		const op = async(() => Promise.resolve(123));
-		globalExpect(op()).toBeUndefined();
-		op.start();
-		await op;
-		globalExpect(op()).toBe(123);
-		const err = /* @__PURE__ */ new Error("fail");
-		const op2 = async(() => Promise.reject(err));
-		op2.start();
-		await op2.catch(() => {});
-		globalExpect(op2()).toBe(err);
-	});
-	it("starts in pending state with no value or reason", () => {
-		const op = async(() => Promise.resolve(1));
-		globalExpect(op.state).toBe("pending");
-		globalExpect(op.pending).toBe(true);
-		globalExpect(op.value).toBeUndefined();
-		globalExpect(op.reason).toBeUndefined();
-		globalExpect(op.result).toBeUndefined();
-		globalExpect(op.pending).toBe(op.state === "pending");
-	});
-	it("transitions to fulfilled after start()", async () => {
-		const op = async(() => Promise.resolve(42));
-		op.start();
-		await op;
-		globalExpect(op.state).toBe("fulfilled");
-		globalExpect(op.pending).toBe(false);
-		globalExpect(op.value).toBe(42);
-		globalExpect(op.reason).toBeUndefined();
-		globalExpect(op.result).toBe(42);
-		globalExpect(op.result).toBe(42);
-	});
-	it("transitions to rejected after start()", async () => {
-		const err = /* @__PURE__ */ new Error("fail");
-		const op = async(() => Promise.reject(err));
-		op.start();
-		await op.catch(() => {});
-		globalExpect(op.state).toBe("rejected");
-		globalExpect(op.pending).toBe(false);
-		globalExpect(op.reason).toBe(err);
-		globalExpect(op.value).toBeUndefined();
-		globalExpect(op.result).toBe(err);
-		globalExpect(op.reason).toBe(err);
-	});
-	it("await op.run(args) resolves to the fulfilled value", async () => {
-		const op = async((x) => Promise.resolve(x + 100));
-		globalExpect(await op.run(23)).toBe(123);
-		globalExpect(op.value).toBe(123);
-		globalExpect(op.state).toBe("fulfilled");
-	});
-	it("run() resolves to the fulfilled value", async () => {
-		globalExpect(await async((x) => Promise.resolve(x * 2)).run(5)).toBe(10);
-	});
-	it("await op resolves to the fulfilled value", async () => {
-		const op = async(() => Promise.resolve(7));
-		op.start();
-		globalExpect(await op).toBe(7);
-	});
-	it("await op.catch() resolves on rejection", async () => {
-		const err = /* @__PURE__ */ new Error("fail");
-		const op = async(() => Promise.reject(err));
-		op.start();
-		globalExpect(await op.catch((e) => e)).toBe(err);
-	});
-	it("delegates .then()", async () => {
-		const op = async(() => Promise.resolve(3));
-		op.start();
-		globalExpect(await op.then((v) => (v ?? 0) * 2)).toBe(6);
-	});
-	it("instanceof Async", () => {
-		globalExpect(async(() => Promise.resolve()) instanceof Async).toBe(true);
-	});
-	it("is reactive — effect reruns when state transitions to fulfilled", async () => {
-		const op = async(() => Promise.resolve(10));
-		const snapshots = [];
-		const stop = effect(() => {
-			snapshots.push(op.state);
-		});
-		op.start();
-		await op;
-		stop();
-		globalExpect(snapshots).toContain("pending");
-		globalExpect(snapshots.at(-1)).toBe("fulfilled");
-	});
-	it("is reactive — effect sees value after fulfillment", async () => {
-		const op = async(() => Promise.resolve(99));
-		const values = [];
-		const stop = effect(() => {
-			values.push(op.value);
-		});
-		op.start();
-		await op;
-		stop();
-		globalExpect(values).toEqual([
-			void 0,
-			void 0,
-			99
-		]);
-	});
-	it("is reactive — effect reruns on rejection", async () => {
-		const err = /* @__PURE__ */ new Error("x");
-		const op = async(() => Promise.reject(err));
-		const reasons = [];
-		const stop = effect(() => {
-			reasons.push(op.reason);
-		});
-		op.start();
-		await op.catch(() => {});
-		stop();
-		globalExpect(reasons).toEqual([
-			void 0,
-			void 0,
-			err
-		]);
-	});
-	it("start() re-runs when a signal read inside fn changes", async () => {
-		const id = signal(1);
-		const calls = [];
-		const op = async(() => {
-			const current = id();
-			calls.push(current);
-			return Promise.resolve(current);
-		});
-		op.start();
-		await op;
-		id(2);
-		await op;
-		op.stop();
-		globalExpect(calls).toEqual([1, 2]);
-	});
-	it("run() is not reactive — signal change does not re-run", async () => {
-		const id = signal(1);
-		const calls = [];
-		const op = async(() => {
-			const current = id();
-			calls.push(current);
-			return Promise.resolve(current);
-		});
-		op.run();
-		await op;
-		id(2);
-		await Promise.resolve();
-		op.stop();
-		globalExpect(calls).toEqual([1]);
-	});
-	it("start() resets to pending on re-run", async () => {
-		const d = deferred();
-		const id = signal(1);
-		const op = async(() => {
-			id();
-			return d.promise;
-		});
-		op.start();
-		globalExpect(op.pending).toBe(true);
-		id(2);
-		globalExpect(op.pending).toBe(true);
-		d.resolve(5);
-		op.stop();
-	});
-	it("stop() prevents further reactive reruns", async () => {
-		const id = signal(1);
-		const calls = [];
-		const op = async(() => {
-			calls.push(id());
-			return Promise.resolve(id());
-		});
-		op.start();
-		await op;
-		op.stop();
-		id(2);
-		await Promise.resolve();
-		globalExpect(calls).toEqual([1]);
-	});
-	it("onCleanup inside run() fires when stop() is called", () => {
-		const cleaned = [];
-		const op = async(() => {
-			onCleanup(() => cleaned.push(1));
-			return Promise.resolve();
-		});
-		op.run();
-		globalExpect(cleaned).toEqual([]);
-		op.stop();
-		globalExpect(cleaned).toEqual([1]);
-	});
-	it("onCleanup inside start() fires on each re-run", async () => {
-		const id = signal(1);
-		const cleaned = [];
-		const op = async(() => {
-			const current = id();
-			onCleanup(() => cleaned.push(current));
-			return Promise.resolve();
-		});
-		op.start();
-		await op;
-		id(2);
-		await op;
-		op.stop();
-		globalExpect(cleaned[0]).toBe(1);
-	});
-	it("re-runs when createInterval ticks", async () => {
-		vi.useFakeTimers();
-		const timer = createInterval(1e3);
-		const calls = [];
-		const op = async(() => {
-			timer.timestamp();
-			calls.push(calls.length);
-			return Promise.resolve(calls.length);
-		});
-		op.start();
-		await op;
-		globalExpect(calls.length).toBe(1);
-		vi.advanceTimersByTime(1e3);
-		await op;
-		globalExpect(calls.length).toBe(2);
-		op.stop();
-		timer.stop();
-		vi.useRealTimers();
-	});
-	it("state and value update atomically — no inconsistent intermediate state", async () => {
-		const op = async(() => Promise.resolve(7));
-		const snapshots = [];
-		const stop = effect(() => {
-			snapshots.push({
-				state: op.state,
-				value: op.value
-			});
-		});
-		op.start();
-		await op;
-		stop();
-		globalExpect(snapshots.find((s) => s.state === "fulfilled" && s.value === void 0)).toBeUndefined();
-		globalExpect(snapshots.at(-1)).toEqual({
-			state: "fulfilled",
-			value: 7
-		});
-	});
-});
-//#endregion
-export {};

package/dist/utilities/context.test.d.mts

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

package/dist/utilities/context.test.mjs

@@ -1,171 +0,0 @@
-import { c as effectScope, m as signal, s as effect } from "../lib-Dkc7cV5F.mjs";
-import "../signals/index.mjs";
-import { f as it, l as describe, o as afterEach } from "../benchmark.CX_oY03V-CSLAXL5f.mjs";
-import { n as vi, t as globalExpect } from "../test.BmQO5GaM-Ddz9cDxc.mjs";
-import { getContext, setContext } from "./context.mjs";
-//#region src/utilities/context.test.ts
-afterEach(() => {
-	document.body.innerHTML = "";
-});
-describe("context", () => {
-	it("returns undefined when no provider exists above the consumer", () => {
-		const el = document.createElement("div");
-		document.body.appendChild(el);
-		globalExpect(getContext(el, "missing")).toBeUndefined();
-	});
-	it("resolves a value across one parent boundary", () => {
-		const host = document.createElement("section");
-		const child = document.createElement("span");
-		host.appendChild(child);
-		document.body.appendChild(host);
-		effectScope(() => {
-			setContext(host, "k", 42);
-		});
-		globalExpect(getContext(child, "k")).toBe(42);
-	});
-	it("propagates updates when the value is a Signal", () => {
-		const host = document.createElement("section");
-		const child = document.createElement("span");
-		host.appendChild(child);
-		document.body.appendChild(host);
-		const value = signal(1);
-		const seen = vi.fn();
-		effectScope(() => {
-			setContext(host, "n", value);
-		});
-		effect(() => {
-			seen(getContext(child, "n")?.());
-		});
-		globalExpect(seen).toHaveBeenLastCalledWith(1);
-		value(2);
-		globalExpect(seen).toHaveBeenLastCalledWith(2);
-	});
-	it("innermost provider wins when nested with the same key", () => {
-		const outer = document.createElement("section");
-		const inner = document.createElement("section");
-		const leaf = document.createElement("span");
-		outer.appendChild(inner);
-		inner.appendChild(leaf);
-		document.body.appendChild(outer);
-		effectScope(() => {
-			setContext(outer, "k", "outer");
-			setContext(inner, "k", "inner");
-		});
-		globalExpect(getContext(leaf, "k")).toBe("inner");
-	});
-	it("disposing the provider's scope removes the entry and falls through", () => {
-		const outer = document.createElement("section");
-		const inner = document.createElement("section");
-		const leaf = document.createElement("span");
-		outer.appendChild(inner);
-		inner.appendChild(leaf);
-		document.body.appendChild(outer);
-		const stopOuter = effectScope(() => {
-			setContext(outer, "k", "outer");
-		});
-		const stopInner = effectScope(() => {
-			setContext(inner, "k", "inner");
-		});
-		globalExpect(getContext(leaf, "k")).toBe("inner");
-		stopInner();
-		globalExpect(getContext(leaf, "k")).toBe("outer");
-		stopOuter();
-		globalExpect(getContext(leaf, "k")).toBeUndefined();
-	});
-	it("distinct keys do not cross-talk", () => {
-		const host = document.createElement("section");
-		const child = document.createElement("span");
-		host.appendChild(child);
-		document.body.appendChild(host);
-		const A = Symbol("a");
-		const B = Symbol("b");
-		effectScope(() => {
-			setContext(host, A, "value-a");
-			setContext(host, B, "value-b");
-		});
-		globalExpect(getContext(child, A)).toBe("value-a");
-		globalExpect(getContext(child, B)).toBe("value-b");
-		globalExpect(getContext(child, "c")).toBeUndefined();
-	});
-	it("crosses an open shadow root via getRootNode().host", () => {
-		const host = document.createElement("section");
-		const shadow = host.attachShadow({ mode: "open" });
-		const inner = document.createElement("span");
-		shadow.appendChild(inner);
-		document.body.appendChild(host);
-		effectScope(() => {
-			setContext(host, "k", "from-host");
-		});
-		globalExpect(getContext(inner, "k")).toBe("from-host");
-	});
-	it("moving the consumer picks up the new ancestor on next get", () => {
-		const a = document.createElement("section");
-		const b = document.createElement("section");
-		const leaf = document.createElement("span");
-		a.appendChild(leaf);
-		document.body.append(a, b);
-		effectScope(() => {
-			setContext(a, "k", "a");
-			setContext(b, "k", "b");
-		});
-		globalExpect(getContext(leaf, "k")).toBe("a");
-		b.appendChild(leaf);
-		globalExpect(getContext(leaf, "k")).toBe("b");
-	});
-	it("returns undefined for an orphan element not in any tree", () => {
-		globalExpect(getContext(document.createElement("div"), "k")).toBeUndefined();
-	});
-	it("two providers with different keys in the same subtree both resolve", () => {
-		const host = document.createElement("section");
-		const leaf = document.createElement("span");
-		host.appendChild(leaf);
-		document.body.appendChild(host);
-		effectScope(() => {
-			setContext(host, "x", 1);
-			setContext(host, "y", 2);
-		});
-		globalExpect(getContext(leaf, "x")).toBe(1);
-		globalExpect(getContext(leaf, "y")).toBe(2);
-	});
-	describe("with <dom-lifecycle> as wrapper", () => {
-		it("descendants resolve a context set on the lifecycle wrapper itself", () => {
-			const wrapper = document.createElement("dom-lifecycle");
-			const consumer = document.createElement("button");
-			wrapper.appendChild(consumer);
-			document.body.appendChild(wrapper);
-			effectScope(() => {
-				setContext(wrapper, "theme", "dark");
-			});
-			globalExpect(getContext(consumer, "theme")).toBe("dark");
-		});
-		it("the wrapper is transparent in the ancestor walk — outer providers still resolve", () => {
-			const provider = document.createElement("section");
-			document.body.appendChild(provider);
-			effectScope(() => {
-				setContext(provider, "theme", "outer");
-			});
-			const wrapper = document.createElement("dom-lifecycle");
-			const consumer = document.createElement("button");
-			wrapper.appendChild(consumer);
-			provider.appendChild(wrapper);
-			globalExpect(getContext(consumer, "theme")).toBe("outer");
-		});
-		it("the wrapper shadows an outer provider when both register the same key", () => {
-			const provider = document.createElement("section");
-			document.body.appendChild(provider);
-			effectScope(() => {
-				setContext(provider, "theme", "outer");
-			});
-			const wrapper = document.createElement("dom-lifecycle");
-			const consumer = document.createElement("button");
-			wrapper.appendChild(consumer);
-			provider.appendChild(wrapper);
-			effectScope(() => {
-				setContext(wrapper, "theme", "inner");
-			});
-			globalExpect(getContext(consumer, "theme")).toBe("inner");
-		});
-	});
-});
-//#endregion
-export {};

package/dist/utilities/debounced.test.d.mts

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

package/dist/utilities/debounced.test.mjs

@@ -1,68 +0,0 @@
-import { c as effectScope, m as signal } from "../lib-Dkc7cV5F.mjs";
-import "../signals/index.mjs";
-import { c as beforeEach, f as it, l as describe, o as afterEach } from "../benchmark.CX_oY03V-CSLAXL5f.mjs";
-import { n as vi, t as globalExpect } from "../test.BmQO5GaM-Ddz9cDxc.mjs";
-import { createDebounced } from "./debounced.mjs";
-//#region src/utilities/debounced.test.ts
-beforeEach(() => {
-	vi.useFakeTimers();
-});
-afterEach(() => {
-	vi.useRealTimers();
-});
-describe("createDebounced", () => {
-	it("returns the initial value synchronously", () => {
-		const s = signal(42);
-		let d;
-		effectScope(() => {
-			d = createDebounced(() => s(), 100);
-		});
-		globalExpect(d()).toBe(42);
-	});
-	it("does not update before the delay elapses", () => {
-		const s = signal(0);
-		let d;
-		effectScope(() => {
-			d = createDebounced(() => s(), 100);
-		});
-		s(1);
-		vi.advanceTimersByTime(50);
-		globalExpect(d()).toBe(0);
-	});
-	it("updates after the delay elapses", () => {
-		const s = signal(0);
-		let d;
-		effectScope(() => {
-			d = createDebounced(() => s(), 100);
-		});
-		s(1);
-		vi.advanceTimersByTime(100);
-		globalExpect(d()).toBe(1);
-	});
-	it("resets the timer on each rapid change", () => {
-		const s = signal(0);
-		let d;
-		effectScope(() => {
-			d = createDebounced(() => s(), 100);
-		});
-		s(1);
-		vi.advanceTimersByTime(50);
-		s(2);
-		vi.advanceTimersByTime(50);
-		globalExpect(d()).toBe(0);
-		vi.advanceTimersByTime(50);
-		globalExpect(d()).toBe(2);
-	});
-	it("stops updating after scope disposal", () => {
-		const s = signal(0);
-		let d;
-		effectScope(() => {
-			d = createDebounced(() => s(), 100);
-		})();
-		s(99);
-		vi.advanceTimersByTime(200);
-		globalExpect(d()).toBe(0);
-	});
-});
-//#endregion
-export {};

package/dist/utilities/dom-lifecycle.test.d.mts

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