phase 0.0.6 → 0.0.8

package/dist/{pointer-D5F7_Jjs.js → debounce-D5ugkrXN.js}

@@ -1207,6 +1207,415 @@ function createPointer(options) {
 	};
 }
 //#endregion
-export { invalidDurationError as _, whenIdle as a, serverContextError as b, createRenderState as c, createLifecycle as d, readMediaQuery as f, PhaseError as g, createTicker as h, prefersReducedMotion as i, createScrollProgress as l, createSight as m, createMutation as n, readDpr as o, subscribeMediaQuery as p, REDUCED_MOTION_QUERY as r, subscribeDpr as s, createPointer as t, createLoop as u, isPhaseError as v, linkAbortSignal as x, missingContextError as y };
+//#region src/core/_internal/pool/ro-pool.ts
+let observer = null;
+const callbacks = /* @__PURE__ */ new Map();
+/**
+* Observe an element via a singleton ResizeObserver.
+* One RO instance for the entire page. Per-element `box` options are
+* forwarded to `ResizeObserver.observe()`.
+*
+* @returns Cleanup function that unobserves the element.
+*/
+function observeResize(element, callback, box) {
+	callbacks.set(element, callback);
+	getObserver().observe(element, box ? { box } : void 0);
+	let disposed = false;
+	return () => {
+		if (disposed) return;
+		disposed = true;
+		if (callbacks.get(element) === callback) {
+			callbacks.delete(element);
+			observer?.unobserve(element);
+		}
+	};
+}
+/** Lazy-created singleton. RO takes zero constructor options, so one instance can observe everything. */
+function getObserver() {
+	if (!observer) observer = new ResizeObserver((entries) => {
+		for (const entry of entries) {
+			const cb = callbacks.get(entry.target);
+			if (cb) cb(entry);
+		}
+	});
+	return observer;
+}
+//#endregion
+//#region src/core/scroll/index.ts
+/**
+* Lifecycle-aware scroll tracker. Reads `scrollLeft`/`scrollTop` once per rAF
+* frame and reads the reflow-heavy geometry (`scrollWidth`/`clientWidth`) only
+* on resize or explicit `measure()`, never on the scroll path. Auto-pauses when
+* the element is off-screen.
+*
+* This is to `scroll` + `scrollWidth` what `createPointer` is to `pointermove`
+* + `getBoundingClientRect`: the layout read is batched off the hot path so the
+* per-scroll work is a single cheap position read plus math on cached geometry.
+*/
+function createScroll(options) {
+	if (typeof document === "undefined") serverContextError("createScroll");
+	const { element, onScroll, onPhaseChange, visibility = "pause", intersectionOptions, signal } = options;
+	if (!element) noElementError("createScroll");
+	let _phase = "paused";
+	let _reason = "initial";
+	let stopped = false;
+	const _state = {
+		x: 0,
+		y: 0,
+		maxX: 0,
+		maxY: 0,
+		progressX: 0,
+		progressY: 0,
+		visibleX: 1,
+		visibleY: 1
+	};
+	let rafId = 0;
+	let dirty = false;
+	let listenersAttached = false;
+	let unobserveRO;
+	function setPhase(phase, reason) {
+		const prev = _phase;
+		_phase = phase;
+		_reason = reason;
+		if (prev !== phase) onPhaseChange?.(phase, reason);
+	}
+	function computePosition() {
+		const { maxX, maxY } = _state;
+		const x = element.scrollLeft;
+		const y = element.scrollTop;
+		_state.x = x < 0 ? 0 : x > maxX ? maxX : x;
+		_state.y = y < 0 ? 0 : y > maxY ? maxY : y;
+		_state.progressX = maxX > 0 ? _state.x / maxX : 0;
+		_state.progressY = maxY > 0 ? _state.y / maxY : 0;
+	}
+	function measure() {
+		if (stopped || !listenersAttached) return;
+		const scrollWidth = element.scrollWidth;
+		const clientWidth = element.clientWidth;
+		const scrollHeight = element.scrollHeight;
+		const clientHeight = element.clientHeight;
+		const maxX = scrollWidth - clientWidth;
+		const maxY = scrollHeight - clientHeight;
+		_state.maxX = maxX > 0 ? maxX : 0;
+		_state.maxY = maxY > 0 ? maxY : 0;
+		_state.visibleX = maxX > 0 ? clientWidth / scrollWidth : 1;
+		_state.visibleY = maxY > 0 ? clientHeight / scrollHeight : 1;
+		computePosition();
+		onScroll(_state);
+	}
+	function flush() {
+		rafId = 0;
+		if (!dirty || stopped) return;
+		dirty = false;
+		computePosition();
+		onScroll(_state);
+	}
+	function scheduleFlush() {
+		if (rafId !== 0) return;
+		rafId = requestAnimationFrame(flush);
+	}
+	function cancelFlush() {
+		if (rafId !== 0) {
+			cancelAnimationFrame(rafId);
+			rafId = 0;
+		}
+		dirty = false;
+	}
+	function onScrollEvent() {
+		if (stopped) return;
+		dirty = true;
+		scheduleFlush();
+	}
+	function onROResize() {
+		if (stopped) return;
+		measure();
+	}
+	function attachListeners() {
+		if (listenersAttached) return;
+		listenersAttached = true;
+		element.addEventListener("scroll", onScrollEvent, { passive: true });
+		unobserveRO = observeResize(element, onROResize);
+		measure();
+	}
+	function detachListeners() {
+		if (!listenersAttached) return;
+		listenersAttached = false;
+		element.removeEventListener("scroll", onScrollEvent);
+		unobserveRO?.();
+		unobserveRO = void 0;
+		cancelFlush();
+	}
+	let cleanupVisibility;
+	if (visibility === "pause") {
+		let elementInView = false;
+		let documentVisible = !document.hidden;
+		function recompute() {
+			if (stopped) return;
+			const shouldTrack = documentVisible && elementInView;
+			if (shouldTrack && !listenersAttached) {
+				setPhase("tracking", "started");
+				attachListeners();
+			} else if (!shouldTrack && listenersAttached) {
+				detachListeners();
+				setPhase("paused", "sight");
+			}
+		}
+		function onVisChange() {
+			documentVisible = !document.hidden;
+			recompute();
+		}
+		function onPageShow(event) {
+			if (!event.persisted) return;
+			documentVisible = true;
+			recompute();
+		}
+		document.addEventListener("visibilitychange", onVisChange);
+		window.addEventListener("pageshow", onPageShow);
+		const unobserveIO = observeIntersection({
+			element,
+			onIntersect: (entry) => {
+				elementInView = entry.isIntersecting;
+				recompute();
+			},
+			...intersectionOptions
+		});
+		cleanupVisibility = () => {
+			document.removeEventListener("visibilitychange", onVisChange);
+			window.removeEventListener("pageshow", onPageShow);
+			unobserveIO();
+		};
+	} else {
+		setPhase("tracking", "started");
+		attachListeners();
+	}
+	let unlinkAbort;
+	function stop() {
+		if (stopped) return;
+		stopped = true;
+		unlinkAbort?.();
+		cleanupVisibility?.();
+		detachListeners();
+		cancelFlush();
+		setPhase("stopped", "disposed");
+	}
+	unlinkAbort = linkAbortSignal(signal, stop);
+	return {
+		get phase() {
+			return _phase;
+		},
+		get phaseReason() {
+			return _reason;
+		},
+		get state() {
+			return _state;
+		},
+		measure,
+		stop
+	};
+}
+//#endregion
+//#region src/core/throttle/index.ts
+/**
+* Frame-aligned, visibility-aware throttle. Leading calls fire synchronously;
+* a pending trailing call rides a one-shot rAF chain and fires with the latest
+* value on the first frame at or past `interval`. While the document is hidden
+* nothing is scheduled: a pending call is flushed or dropped per `hidden`, and
+* new calls are recorded but deferred until the document is visible again.
+*
+* @remarks
+* `call` takes exactly one value and stores it by reference, so the hot path
+* never allocates. Trailing calls read the value at fire time.
+*/
+function createThrottle(options) {
+	if (typeof document === "undefined") serverContextError("createThrottle");
+	const { callback, interval, edge = "both", hidden = "flush", signal } = options;
+	const leading = edge !== "trailing";
+	const trailing = edge !== "leading";
+	let stopped = false;
+	let pending = false;
+	let lastFire = 0;
+	let rafId = 0;
+	let documentVisible = !document.hidden;
+	let latest = void 0;
+	function fire(now) {
+		lastFire = now;
+		pending = false;
+		callback(latest);
+	}
+	function cancelRaf() {
+		if (rafId !== 0) {
+			cancelAnimationFrame(rafId);
+			rafId = 0;
+		}
+	}
+	function tick() {
+		rafId = 0;
+		if (stopped || !pending) return;
+		const now = performance.now();
+		if (now - lastFire >= interval) fire(now);
+		else rafId = requestAnimationFrame(tick);
+	}
+	function scheduleRaf() {
+		if (rafId === 0) rafId = requestAnimationFrame(tick);
+	}
+	function call(value) {
+		if (stopped) return;
+		latest = value;
+		if (!documentVisible) {
+			pending = true;
+			return;
+		}
+		const now = performance.now();
+		if (now - lastFire >= interval) {
+			if (leading) {
+				fire(now);
+				return;
+			}
+			lastFire = now;
+		}
+		if (trailing) {
+			pending = true;
+			scheduleRaf();
+		}
+	}
+	function flush() {
+		if (stopped || !pending) return;
+		cancelRaf();
+		fire(performance.now());
+	}
+	function cancel() {
+		if (stopped) return;
+		cancelRaf();
+		pending = false;
+		lastFire = 0;
+	}
+	function onVisibilityChange() {
+		documentVisible = !document.hidden;
+		if (stopped) return;
+		if (!documentVisible) {
+			cancelRaf();
+			if (pending) if (hidden === "flush") fire(performance.now());
+			else pending = false;
+		} else if (pending) scheduleRaf();
+	}
+	function onPageShow(event) {
+		if (!event.persisted) return;
+		documentVisible = true;
+		if (!stopped && pending) scheduleRaf();
+	}
+	document.addEventListener("visibilitychange", onVisibilityChange);
+	window.addEventListener("pageshow", onPageShow);
+	let unlinkAbort;
+	function stop() {
+		if (stopped) return;
+		stopped = true;
+		unlinkAbort?.();
+		document.removeEventListener("visibilitychange", onVisibilityChange);
+		window.removeEventListener("pageshow", onPageShow);
+		cancelRaf();
+		pending = false;
+	}
+	unlinkAbort = linkAbortSignal(signal, stop);
+	return {
+		call,
+		flush,
+		cancel,
+		get pending() {
+			return pending;
+		},
+		stop
+	};
+}
+//#endregion
+//#region src/core/debounce/index.ts
+/**
+* Visibility-aware trailing debounce. Fires the callback with the latest
+* value once `wait` milliseconds pass without a new call. While the document
+* is hidden no timer runs: a pending call is flushed or dropped per `hidden`,
+* and new calls are recorded but wait until the document is visible again,
+* when the quiet timer restarts.
+*/
+function createDebounce(options) {
+	if (typeof document === "undefined") serverContextError("createDebounce");
+	const { callback, wait, hidden = "flush", signal } = options;
+	let stopped = false;
+	let pending = false;
+	let timer;
+	let documentVisible = !document.hidden;
+	let latest = void 0;
+	function fire() {
+		pending = false;
+		callback(latest);
+	}
+	function clearTimer() {
+		if (timer !== void 0) {
+			clearTimeout(timer);
+			timer = void 0;
+		}
+	}
+	function onTimer() {
+		timer = void 0;
+		if (stopped || !pending) return;
+		fire();
+	}
+	function startTimer() {
+		clearTimer();
+		timer = setTimeout(onTimer, wait);
+	}
+	function call(value) {
+		if (stopped) return;
+		latest = value;
+		pending = true;
+		if (documentVisible) startTimer();
+	}
+	function flush() {
+		if (stopped || !pending) return;
+		clearTimer();
+		fire();
+	}
+	function cancel() {
+		if (stopped) return;
+		clearTimer();
+		pending = false;
+	}
+	function onVisibilityChange() {
+		documentVisible = !document.hidden;
+		if (stopped) return;
+		if (!documentVisible) {
+			clearTimer();
+			if (pending) if (hidden === "flush") fire();
+			else pending = false;
+		} else if (pending) startTimer();
+	}
+	function onPageShow(event) {
+		if (!event.persisted) return;
+		documentVisible = true;
+		if (!stopped && pending) startTimer();
+	}
+	document.addEventListener("visibilitychange", onVisibilityChange);
+	window.addEventListener("pageshow", onPageShow);
+	let unlinkAbort;
+	function stop() {
+		if (stopped) return;
+		stopped = true;
+		unlinkAbort?.();
+		document.removeEventListener("visibilitychange", onVisibilityChange);
+		window.removeEventListener("pageshow", onPageShow);
+		clearTimer();
+		pending = false;
+	}
+	unlinkAbort = linkAbortSignal(signal, stop);
+	return {
+		call,
+		flush,
+		cancel,
+		get pending() {
+			return pending;
+		},
+		stop
+	};
+}
+//#endregion
+export { missingContextError as C, isPhaseError as S, linkAbortSignal as T, subscribeMediaQuery as _, createPointer as a, PhaseError as b, prefersReducedMotion as c, subscribeDpr as d, createRenderState as f, readMediaQuery as g, createLifecycle as h, observeResize as i, whenIdle as l, createLoop as m, createThrottle as n, createMutation as o, createScrollProgress as p, createScroll as r, REDUCED_MOTION_QUERY as s, createDebounce as t, readDpr as u, createSight as v, serverContextError as w, invalidDurationError as x, createTicker as y };
 
-//# sourceMappingURL=pointer-D5F7_Jjs.js.map
+//# sourceMappingURL=debounce-D5ugkrXN.js.map