@farm.js/islx 0.0.0-stage → 0.0.1

package/dist/_chunks/schedule-BFoGKRrU.mjs

@@ -0,0 +1,216 @@
+import { a as hasPendingInteraction, o as takePendingInteractions, t as INTERACTION_EVENT } from "./prehydration-B1GLTLdk.mjs";
+import { m as HYDRATED_ATTRIBUTE } from "./wire-CXOodE06.mjs";
+// src/client/schedule.ts
+/**
+* When an island hydrates. Renderer-neutral: every adapter schedules through this.
+*
+* - `load`: as soon as the runtime starts (the default).
+* - `idle`: when the browser is idle, or after 2 seconds.
+* - `visible`: when the island comes within 200px of the viewport.
+* - `interaction`: on the first click, submit, pointerdown or focus inside it. A click or a
+*   submit is held while the island's code loads, then replayed on the hydrated island, so the
+*   user's first action is not lost.
+*
+* Until it hydrates, an island is its server HTML: links and native forms keep working.
+*/
+const ISLAND_STRATEGIES = [
+	"load",
+	"idle",
+	"visible",
+	"interaction"
+];
+function isIslandStrategy(value) {
+	return ISLAND_STRATEGIES.includes(value);
+}
+/** Elements whose click is held and replayed rather than merely observed. */
+const REPLAYABLE = "button,[role=\"button\"],input[type=\"button\"],input[type=\"submit\"],input[type=\"reset\"]";
+function whenIdle(callback) {
+	const scope = window;
+	if (typeof scope.requestIdleCallback === "function") {
+		const handle = scope.requestIdleCallback(callback, { timeout: 2e3 });
+		return () => scope.cancelIdleCallback?.(handle);
+	}
+	const handle = window.setTimeout(callback, 1);
+	return () => window.clearTimeout(handle);
+}
+const visibility = /* @__PURE__ */ new WeakMap();
+/** One observer per document, shared by every island; targets are released once they fire. */
+function whenVisible(document, targets, start) {
+	let registry = visibility.get(document);
+	if (!registry) {
+		const subscriptions = /* @__PURE__ */ new Map();
+		registry = {
+			observer: new IntersectionObserver((entries) => {
+				const pending = /* @__PURE__ */ new Set();
+				for (const entry of entries) if (entry.isIntersecting) for (const callback of subscriptions.get(entry.target) ?? []) pending.add(callback);
+				for (const callback of pending) callback();
+			}, { rootMargin: "200px" }),
+			targets: subscriptions
+		};
+		visibility.set(document, registry);
+	}
+	const current = registry;
+	for (const target of targets) {
+		let callbacks = current.targets.get(target);
+		if (!callbacks) {
+			callbacks = /* @__PURE__ */ new Set();
+			current.targets.set(target, callbacks);
+			current.observer.observe(target);
+		}
+		callbacks.add(start);
+	}
+	let active = true;
+	return () => {
+		if (!active) return;
+		active = false;
+		for (const target of targets) {
+			const callbacks = current.targets.get(target);
+			callbacks?.delete(start);
+			if (callbacks?.size === 0) {
+				current.targets.delete(target);
+				current.observer.unobserve(target);
+			}
+		}
+		if (current.targets.size === 0) {
+			current.observer.disconnect();
+			visibility.delete(document);
+		}
+	};
+}
+/**
+* Replays a held interaction. `requestSubmit()` dispatches a real submit event, so handlers bound
+* during hydration see it and validation runs; `form.submit()` would bypass both.
+*/
+function replay({ target, kind }) {
+	if (kind === "submit") {
+		const form = target;
+		if (typeof form.requestSubmit === "function") form.requestSubmit();
+		else target.dispatchEvent(new Event("submit", {
+			bubbles: true,
+			cancelable: true
+		}));
+		return;
+	}
+	const clickable = target;
+	if (typeof clickable.click === "function") clickable.click();
+	else target.dispatchEvent(new MouseEvent("click", {
+		bubbles: true,
+		cancelable: true
+	}));
+}
+function finish(container, held) {
+	const interactions = /* @__PURE__ */ new Map();
+	if (held) interactions.set(held.target, held);
+	for (const pending of takePendingInteractions(container)) if (pending.kind) interactions.set(pending.target, {
+		target: pending.target,
+		kind: pending.kind
+	});
+	if (!container.isConnected) return;
+	container.setAttribute(HYDRATED_ATTRIBUTE, "");
+	for (const interaction of interactions.values()) window.setTimeout(() => {
+		if (container.isConnected && interaction.target.isConnected && container.contains(interaction.target)) replay(interaction);
+	}, 0);
+}
+/** Runs `hydrate` when the island's strategy says; resolves with its result, or undefined if aborted. */
+function scheduleHydration({ container, strategy, signal, hydrate }) {
+	const resolved = strategy ?? "load";
+	if (signal?.aborted) return Promise.resolve(void 0);
+	if (resolved === "load") return Promise.resolve().then(() => signal?.aborted ? void 0 : hydrate()).then((value) => {
+		if (signal?.aborted) return void 0;
+		finish(container, null);
+		return value;
+	});
+	return new Promise((resolve, reject) => {
+		let started = false;
+		let cancelled = false;
+		let held = null;
+		const triggers = /* @__PURE__ */ new Set();
+		const captures = /* @__PURE__ */ new Set();
+		let removeAbort = null;
+		const cleanupTriggers = () => {
+			for (const dispose of triggers) dispose();
+			triggers.clear();
+		};
+		const cleanup = () => {
+			cleanupTriggers();
+			for (const dispose of captures) dispose();
+			captures.clear();
+			removeAbort?.();
+			removeAbort = null;
+		};
+		const start = () => {
+			if (started || cancelled) return;
+			started = true;
+			cleanupTriggers();
+			Promise.resolve().then(hydrate).then((value) => {
+				cleanup();
+				if (cancelled || signal?.aborted) return;
+				finish(container, held);
+				resolve(value);
+			}, (error) => {
+				cleanup();
+				reject(error);
+			});
+		};
+		if (signal) {
+			const abort = () => {
+				cancelled = true;
+				cleanup();
+				resolve(void 0);
+			};
+			signal.addEventListener("abort", abort, { once: true });
+			removeAbort = () => signal.removeEventListener("abort", abort);
+		}
+		if (hasPendingInteraction(container)) return start();
+		const onAnnounced = (event) => {
+			const detail = event.detail;
+			if (detail?.target instanceof Element && container.contains(detail.target)) start();
+		};
+		document.addEventListener(INTERACTION_EVENT, onAnnounced);
+		captures.add(() => document.removeEventListener(INTERACTION_EVENT, onAnnounced));
+		if (resolved === "idle") {
+			triggers.add(whenIdle(start));
+			return;
+		}
+		if (resolved === "visible") {
+			if (typeof IntersectionObserver !== "function") return start();
+			const targets = container.getClientRects().length > 0 ? [container] : Array.from(container.children);
+			if (targets.length === 0) return start();
+			triggers.add(whenVisible(container.ownerDocument, targets, start));
+			return;
+		}
+		const hold = (event, target, kind) => {
+			held ??= {
+				target,
+				kind
+			};
+			event.preventDefault();
+			event.stopImmediatePropagation();
+			start();
+		};
+		const onClick = (event) => {
+			const mouse = event;
+			const target = event.target instanceof Element ? event.target.closest(REPLAYABLE) : null;
+			if (!target || !container.contains(target) || target.closest("a[href]") || mouse.button !== 0 || mouse.metaKey || mouse.altKey || mouse.ctrlKey || mouse.shiftKey) return;
+			hold(event, target, "click");
+		};
+		const onSubmit = (event) => {
+			const form = event.target;
+			if (!(form instanceof Element) || form.nodeName !== "FORM") return;
+			if (!container.contains(form) || event.defaultPrevented) return;
+			hold(event, form, "submit");
+		};
+		const onActivate = (event) => {
+			if (event.target instanceof Element && container.contains(event.target)) start();
+		};
+		const listen = (type, handler) => {
+			document.addEventListener(type, handler, true);
+			captures.add(() => document.removeEventListener(type, handler, true));
+		};
+		listen("click", onClick);
+		listen("submit", onSubmit);
+		listen("pointerdown", onActivate);
+		listen("focusin", onActivate);
+	});
+}
+export { isIslandStrategy as n, scheduleHydration as r, ISLAND_STRATEGIES as t };

package/dist/_chunks/schedule-Dw14dW0H.d.mts

@@ -0,0 +1,17 @@
+type IslandStrategy = "load" | "idle" | "visible" | "interaction";
+declare const ISLAND_STRATEGIES: readonly IslandStrategy[];
+declare function isIslandStrategy(value: unknown): value is IslandStrategy;
+interface ScheduleOptions<T> {
+  container: Element;
+  strategy?: IslandStrategy | null;
+  signal?: AbortSignal;
+  hydrate(): T | Promise<T>;
+}
+/** Runs `hydrate` when the island's strategy says; resolves with its result, or undefined if aborted. */
+declare function scheduleHydration<T>({
+  container,
+  strategy,
+  signal,
+  hydrate
+}: ScheduleOptions<T>): Promise<T | undefined>;
+export { scheduleHydration as a, isIslandStrategy as i, IslandStrategy as n, ScheduleOptions as r, ISLAND_STRATEGIES as t };