@farm.js/islx 0.0.0-stage → 0.0.2

package/dist/_chunks/actions-2sTj0A2T.mjs

@@ -0,0 +1,306 @@
+import { A as VALUE_SCRIPT_TYPE, N as getTag, O as VALUES_HEADER, j as attachmentField, k as VALUE_KEY_PATTERN, o as BOUND_FIELD, s as CALL_FIELD, t as ACTION_HEADER } from "./wire-CXOodE06.mjs";
+import { a as encode, r as decode, u as setOwn } from "./codec-DqfVYKsx.mjs";
+// src/client/value-store.ts
+/**
+* The browser's store of values sent once. It keeps every value it has read, parses each once,
+* and gives islands that share a value the same object. A navigation names the keys it holds
+* (`valueHeaders()`), so the server leaves those values out.
+*/
+/** Past this many values the store starts over at the next navigation. */
+const MAX_STORED_VALUES = 1024;
+const STORE_KEY = Symbol.for("islx.values");
+function createValueStore() {
+	const entries = /* @__PURE__ */ new Map();
+	const read = /* @__PURE__ */ new WeakSet();
+	const get = (key) => {
+		const entry = entries.get(key);
+		if (!entry) throw new Error(`islx value ${key} was not found`);
+		entries.delete(key);
+		entries.set(key, entry);
+		if (entry.state === "resolved") return entry.value;
+		if (entry.state === "resolving") throw new Error(`islx value ${key} refers to itself`);
+		entry.state = "resolving";
+		try {
+			const parsed = JSON.parse(entry.json);
+			entry.value = entry.json.includes(`"\$"`) ? resolve(parsed) : parsed;
+		} catch (error) {
+			entry.state = "raw";
+			throw error;
+		}
+		entry.state = "resolved";
+		entry.json = "";
+		return entry.value;
+	};
+	const resolve = (value) => {
+		if (Array.isArray(value)) return value.map(resolve);
+		if (!value || typeof value !== "object") return value;
+		const object = value;
+		const tag = getTag(object);
+		if (tag === "r" && typeof object["v"] === "string") return get(object["v"]);
+		if (tag === "o" && object["v"] && typeof object["v"] === "object") return {
+			["$"]: "o",
+			["v"]: resolveEntries(object["v"])
+		};
+		return resolveEntries(object);
+	};
+	const resolveEntries = (object) => {
+		const resolved = {};
+		for (const key of Object.keys(object)) setOwn(resolved, key, resolve(object[key]));
+		return resolved;
+	};
+	return {
+		ingest(root) {
+			for (const script of root.querySelectorAll(`script[type="${VALUE_SCRIPT_TYPE}"]`)) {
+				if (read.has(script)) continue;
+				read.add(script);
+				const key = script.getAttribute("name") ?? "";
+				if (VALUE_KEY_PATTERN.test(key) && !entries.has(key)) entries.set(key, {
+					json: script.textContent || "null",
+					state: "raw"
+				});
+			}
+		},
+		resolve,
+		heldHeader() {
+			if (entries.size > MAX_STORED_VALUES) entries.clear();
+			if (entries.size === 0) return void 0;
+			return [...entries.keys()].slice(-128).join(",");
+		},
+		clear() {
+			entries.clear();
+		}
+	};
+}
+/** The page's value store, shared by every copy of islx on the page. */
+function getValueStore() {
+	const scope = globalThis;
+	return scope[STORE_KEY] ??= createValueStore();
+}
+/** Headers a navigation sends so the server can leave out values the browser holds. */
+function valueHeaders() {
+	const held = globalThis[STORE_KEY]?.heldHeader();
+	return held ? { [VALUES_HEADER]: held } : {};
+}
+// src/client/hooks.ts
+const HOOKS_KEY = Symbol.for("islx.client.hooks");
+const CANCELABLE = /* @__PURE__ */ new Set(["navigate"]);
+/** Types an app's hooks module. */
+function defineClientHooks(hooks) {
+	return hooks;
+}
+/** Installs the app's hooks; the plugin's browser entry calls it. */
+function setClientHooks(hooks) {
+	globalThis[HOOKS_KEY] = hooks;
+}
+/** The DOM event name of a hook: `navigateError` → `f:navigate-error`. */
+function hookEventName(name) {
+	return `f:${name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}`;
+}
+/**
+* Runs a hook and dispatches its DOM event. Returns false when it was cancelled. A hook that
+* throws is reported, never allowed to break navigation or hydration.
+*/
+function emit(name, detail) {
+	const cancelable = CANCELABLE.has(name);
+	let prevented = false;
+	const event = {
+		...detail,
+		preventDefault() {
+			if (cancelable) prevented = true;
+		},
+		get defaultPrevented() {
+			return prevented;
+		}
+	};
+	const hook = globalThis[HOOKS_KEY]?.[name];
+	if (hook) try {
+		hook(event);
+	} catch (error) {
+		console.error(`[islx] The ${name} hook failed:`, error);
+	}
+	if (typeof document !== "undefined" && typeof CustomEvent === "function") {
+		const dom = new CustomEvent(hookEventName(name), {
+			detail,
+			cancelable
+		});
+		if (!document.dispatchEvent(dom)) prevented = cancelable;
+	}
+	return !prevented;
+}
+// src/client/actions.ts
+/**
+* The browser side of server actions. A client module's import of a `"use server"` module
+* becomes references made here, and an action passed as a prop arrives as one.
+*
+* Calls run one at a time, in order, as React expects of actions. After each, the page refreshes
+* (through the framework's router) so it shows what the action changed; a redirect from the
+* action navigates instead. An action this server no longer knows, as after a deploy, reloads the
+* page.
+*/
+const STATE_KEY = Symbol.for("islx.actions.client");
+function state() {
+	const scope = globalThis;
+	return scope[STATE_KEY] ??= {
+		navigator: {},
+		queue: Promise.resolve(),
+		references: /* @__PURE__ */ new Map(),
+		info: /* @__PURE__ */ new WeakMap()
+	};
+}
+/** Connects actions to the framework's router. */
+function setActionNavigator(navigator) {
+	state().navigator = navigator;
+}
+/** Encodes an action passed back to the server as an argument. */
+function encodeFunction(value) {
+	const reference = state().info.get(value);
+	if (!reference) return void 0;
+	if (reference.bound.length > 0) throw new TypeError("an action bound in the browser cannot be sent to the server");
+	return reference.token === void 0 ? {
+		["$"]: "a",
+		["v"]: reference.id
+	} : {
+		["$"]: "a",
+		["v"]: reference.id,
+		["b"]: reference.token
+	};
+}
+/** Decodes an action in a result or props: `{"$":"a","v":id,"b"?:sealed}`. */
+function decodeActionReference(object) {
+	if (object["$"] !== "a" || typeof object["v"] !== "string") return void 0;
+	const token = object["b"];
+	if (token !== void 0 && typeof token !== "string") return void 0;
+	return createServerReference(object["v"], token);
+}
+/** Returned by a call whose action this deploy no longer knows: the page reloads. */
+const STALE = Symbol("islx.action.stale");
+async function call(reference, args) {
+	const all = [...reference.bound, ...args];
+	const single = all.length === 1 && all[0] instanceof FormData ? all[0] : null;
+	let body;
+	const headers = { [ACTION_HEADER]: reference.id };
+	if (single) {
+		const form = new FormData();
+		for (const [key, value] of single) form.append(key, value);
+		if (reference.token !== void 0) form.append(BOUND_FIELD, reference.token);
+		body = form;
+	} else {
+		const attachments = [];
+		const encodeObject = (value) => {
+			if (value instanceof FormData || value instanceof Blob) {
+				attachments.push(value);
+				return {
+					["$"]: value instanceof FormData ? "F" : "K",
+					["v"]: attachments.length - 1
+				};
+			}
+		};
+		const json = JSON.stringify({
+			a: encode(all, {
+				encodeFunction,
+				encodeObject
+			}),
+			b: reference.token
+		});
+		if (attachments.length === 0) {
+			headers["content-type"] = "text/plain;charset=UTF-8";
+			body = json;
+		} else {
+			const form = new FormData();
+			form.append(CALL_FIELD, json);
+			attachments.forEach((attachment, index) => {
+				if (attachment instanceof FormData) for (const [key, value] of attachment) form.append(attachmentField(index, key), value);
+				else form.append(attachmentField(index), attachment);
+			});
+			body = form;
+		}
+	}
+	const response = await fetch(location.href, {
+		method: "POST",
+		headers,
+		body,
+		credentials: "same-origin"
+	});
+	if (response.headers.get("F-Action-Stale")) {
+		location.reload();
+		return STALE;
+	}
+	if (!response.ok) throw new Error(`Server action failed: ${response.status}`);
+	const payload = await response.json();
+	const navigator = state().navigator;
+	if (typeof payload.redirect === "string") {
+		reference.redirect = payload.redirect;
+		if (navigator.navigate) await navigator.navigate(payload.redirect);
+		else location.assign(payload.redirect);
+		return;
+	}
+	const result = decode(payload.result, { decodeReference: decodeActionReference });
+	if (navigator.refresh) await navigator.refresh();
+	return result;
+}
+function createReference(reference) {
+	const client = state();
+	const fn = (...args) => {
+		const { id, name } = reference;
+		let startedAt = 0;
+		const run = async () => {
+			emit("action", {
+				id,
+				name
+			});
+			startedAt = performance.now();
+			reference.redirect = void 0;
+			return call(reference, args);
+		};
+		const result = client.queue.then(run).then((value) => {
+			if (value !== STALE) {
+				const { redirect } = reference;
+				emit("actionEnd", {
+					id,
+					name,
+					ok: true,
+					duration: performance.now() - startedAt,
+					redirect
+				});
+			}
+			return value;
+		}, (error) => {
+			emit("actionEnd", {
+				id,
+				name,
+				ok: false,
+				duration: performance.now() - startedAt,
+				error
+			});
+			throw error;
+		});
+		client.queue = result.then(() => {}, () => {});
+		return result.then((value) => value === STALE ? new Promise(() => {}) : value);
+	};
+	client.info.set(fn, reference);
+	Object.defineProperty(fn, "bind", {
+		configurable: true,
+		value: (_thisArg, ...args) => createReference({
+			...reference,
+			bound: [...reference.bound, ...args]
+		})
+	});
+	return fn;
+}
+/** The function that calls a server action; one per id and sealed values, so props keep identity. */
+function createServerReference(id, token, name) {
+	const key = token === void 0 ? id : `${id}\0${token}`;
+	const references = state().references;
+	let reference = references.get(key);
+	if (!reference) {
+		reference = createReference({
+			id,
+			token,
+			bound: [],
+			name
+		});
+		references.set(key, reference);
+	}
+	return reference;
+}
+export { emit as a, createValueStore as c, defineClientHooks as i, getValueStore as l, decodeActionReference as n, hookEventName as o, setActionNavigator as r, setClientHooks as s, createServerReference as t, valueHeaders as u };