insomni 0.2.0-alpha.0

package/dist/reactivity-B7I0pvzm.mjs

@@ -0,0 +1,191 @@
+import { t as getLogger } from "./logger-DSyBF3Y_.mjs";
+//#region src/reactivity/signals.ts
+let currentSubscriber = null;
+function track(source) {
+	if (!currentSubscriber) return;
+	source.trackingSubs.add(currentSubscriber);
+	currentSubscriber.deps.add(source);
+}
+function clearDeps(sub) {
+	for (const src of sub.deps) src.trackingSubs.delete(sub);
+	sub.deps.clear();
+}
+function notifyTracking(source) {
+	const subs = Array.from(source.trackingSubs);
+	for (const s of subs) s.notify();
+}
+function runWithSubscriber(sub, body) {
+	clearDeps(sub);
+	const prev = currentSubscriber;
+	currentSubscriber = sub;
+	try {
+		return body();
+	} finally {
+		currentSubscriber = prev;
+	}
+}
+function signal(initial, opts = {}) {
+	const eq = opts.equals ?? Object.is;
+	const source = { trackingSubs: /* @__PURE__ */ new Set() };
+	const pushSubs = /* @__PURE__ */ new Set();
+	let value = initial;
+	let disposed = false;
+	function write(next) {
+		if (disposed) return;
+		if (eq(next, value)) return;
+		value = next;
+		for (const fn of pushSubs) fn(value);
+		notifyTracking(source);
+	}
+	return {
+		get() {
+			track(source);
+			return value;
+		},
+		peek() {
+			return value;
+		},
+		set(v) {
+			write(v);
+		},
+		update(fn) {
+			write(fn(value));
+		},
+		subscribe(fn) {
+			if (disposed) return () => {};
+			pushSubs.add(fn);
+			return () => {
+				pushSubs.delete(fn);
+			};
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			pushSubs.clear();
+			source.trackingSubs.clear();
+		}
+	};
+}
+function computed(fn, opts = {}) {
+	const eq = opts.equals ?? Object.is;
+	const source = { trackingSubs: /* @__PURE__ */ new Set() };
+	const pushSubs = /* @__PURE__ */ new Set();
+	let value;
+	let dirty = true;
+	let initialized = false;
+	function recompute() {
+		runWithSubscriber(sub, () => {
+			value = fn();
+		});
+		dirty = false;
+		initialized = true;
+	}
+	const sub = {
+		deps: /* @__PURE__ */ new Set(),
+		notify() {
+			if (dirty) return;
+			if (source.trackingSubs.size === 0 && pushSubs.size === 0) {
+				dirty = true;
+				return;
+			}
+			const prev = value;
+			const wasInit = initialized;
+			recompute();
+			if (!wasInit || !eq(prev, value)) {
+				for (const f of pushSubs) f(value);
+				notifyTracking(source);
+			}
+		}
+	};
+	return {
+		get() {
+			track(source);
+			if (dirty) recompute();
+			return value;
+		},
+		peek() {
+			if (dirty) recompute();
+			return value;
+		},
+		subscribe(fn) {
+			if (dirty) recompute();
+			pushSubs.add(fn);
+			return () => {
+				pushSubs.delete(fn);
+			};
+		}
+	};
+}
+const microtaskScheduler = (run) => queueMicrotask(run);
+const rafScheduler = (run) => {
+	if (typeof requestAnimationFrame === "function") requestAnimationFrame(run);
+	else queueMicrotask(run);
+};
+let defaultScheduler = typeof requestAnimationFrame === "function" ? rafScheduler : microtaskScheduler;
+function setDefaultScheduler(s) {
+	defaultScheduler = s;
+}
+function syncScheduler() {
+	return (run) => run();
+}
+function microtaskFlush() {
+	return microtaskScheduler;
+}
+function effect(fn, options = {}) {
+	const scheduler = options.scheduler ?? defaultScheduler;
+	let disposed = false;
+	let scheduled = false;
+	let cleanup;
+	const sub = {
+		deps: /* @__PURE__ */ new Set(),
+		notify() {
+			if (disposed || scheduled) return;
+			scheduled = true;
+			scheduler(() => {
+				scheduled = false;
+				if (disposed) return;
+				run();
+			});
+		}
+	};
+	function run() {
+		if (typeof cleanup === "function") {
+			try {
+				cleanup();
+			} catch (err) {
+				getLogger().error("effect cleanup threw:", err);
+			}
+			cleanup = void 0;
+		}
+		cleanup = runWithSubscriber(sub, fn);
+	}
+	run();
+	return () => {
+		if (disposed) return;
+		disposed = true;
+		clearDeps(sub);
+		if (typeof cleanup === "function") try {
+			cleanup();
+		} catch (err) {
+			getLogger().error("effect cleanup threw:", err);
+		}
+	};
+}
+/** Run `fn` with no current tracking context. Reads inside don't register. */
+function untrack(fn) {
+	const prev = currentSubscriber;
+	currentSubscriber = null;
+	try {
+		return fn();
+	} finally {
+		currentSubscriber = prev;
+	}
+}
+function isSignal(v) {
+	return typeof v === "object" && v !== null && typeof v.get === "function" && typeof v.peek === "function" && typeof v.subscribe === "function";
+}
+function toSignal(value) {
+	return isSignal(value) ? value : signal(value);
+}
+//#endregion
+export { setDefaultScheduler as a, toSignal as c, microtaskFlush as i, untrack as l, effect as n, signal as o, isSignal as r, syncScheduler as s, computed as t };

package/dist/reactivity.d.mts

@@ -0,0 +1,2 @@
+import { _ as untrack, a as ReadableSignal, c as SignalOptions, d as isSignal, f as microtaskFlush, g as toSignal, h as syncScheduler, i as EffectOptions, l as computed, m as signal, n as EffectDisposer, o as Scheduler, p as setDefaultScheduler, r as EffectFn, s as Signal, t as Computed, u as effect } from "./index-CmMZCMJT.mjs";
+export { Computed, EffectDisposer, EffectFn, EffectOptions, ReadableSignal, Scheduler, Signal, SignalOptions, computed, effect, isSignal, microtaskFlush, setDefaultScheduler, signal, syncScheduler, toSignal, untrack };

package/dist/reactivity.mjs

@@ -0,0 +1,2 @@
+import { a as setDefaultScheduler, c as toSignal, i as microtaskFlush, l as untrack, n as effect, o as signal, r as isSignal, s as syncScheduler, t as computed } from "./reactivity-B7I0pvzm.mjs";
+export { computed, effect, isSignal, microtaskFlush, setDefaultScheduler, signal, syncScheduler, toSignal, untrack };