@farm.js/islx 0.0.8 → 0.0.9

package/dist/_chunks/island-DXAGP4FN.mjs

@@ -1,269 +0,0 @@
-import { t as getBuildDefaults } from "./build-COIcs7wm.mjs";
-import { M as VALUE_SCRIPT_TYPE, h as ISLAND_ELEMENT, w as SLOT_ELEMENT, x as PROPS_SCRIPT_TYPE, y as PROMISE_SCRIPT_TYPE } from "./wire-QEQWBr5s.mjs";
-import * as React from "react";
-import * as ReactDOM from "react-dom";
-// src/react/island.ts
-/**
-* A client component, as the server renders it: its HTML inside `<f-island>`, and its props in
-* a script after it. Shared by the server and the browser: inside a hydrating island, a nested
-* client component is part of that island's React tree, not an island of its own.
-*
-* The compiler wraps every export of a `"use client"` module with `createIsland` in the server
-* build. The browser build keeps the module as it is.
-*/
-const CLIENT_REFERENCE = Symbol.for("islx.react.client-reference");
-/** The module export an island component renders, or undefined for any other type. */
-function getClientReference(type) {
-	if (!type || typeof type !== "function" && typeof type !== "object") return void 0;
-	return type[CLIENT_REFERENCE];
-}
-/**
-* Makes `element`'s client components part of the React root around it (a layout that hydrates
-* as one root), instead of islands of their own.
-*/
-function withinClientRoot(element) {
-	return React.createElement(getContexts().graph.Provider, { value: true }, element);
-}
-/**
-* Starts islands again below a `withinClientRoot`: the page a hydrating layout keeps as server
-* HTML renders its client components as islands of their own.
-*/
-function isolateIslands(element) {
-	return React.createElement(getContexts().graph.Provider, { value: false }, element);
-}
-const RENDER_STATE_RESOLVER = Symbol.for("islx.react.render-state");
-/**
-* For a framework that knows the request being rendered without React context (a request store):
-* returns the render's settings when no `IslandsProvider` or `renderToStream` gave them. Keep the
-* same `sent` set for the whole response.
-*/
-function setRenderStateResolver(resolve) {
-	globalThis[RENDER_STATE_RESOLVER] = resolve;
-}
-function resolveRenderState() {
-	const resolve = globalThis[RENDER_STATE_RESOLVER];
-	return resolve ? resolve() : null;
-}
-/**
-* Gives islands a render's settings when the framework renders the page itself (not through
-* `renderToStream`): which values the browser holds, and which this render already wrote.
-*/
-function IslandsProvider({ held = null, children }) {
-	const state = React.useMemo(() => ({
-		held: held && held.size > 0 ? held : null,
-		sent: /* @__PURE__ */ new Set()
-	}), [held]);
-	return React.createElement(getContexts().render.Provider, { value: state }, children);
-}
-const SERVER_HOOK = Symbol.for("islx.react.server");
-/** @internal */
-function getIslandServerHook() {
-	return globalThis[SERVER_HOOK];
-}
-/** @internal */
-function setIslandServerHook(hook) {
-	globalThis[SERVER_HOOK] = hook;
-}
-/** Tagged objects the runtime made (slots), as opposed to app data with a "$" key. */
-const runtimeTagged = /* @__PURE__ */ new WeakSet();
-const CONTEXTS = Symbol.for("islx.react.contexts");
-/** @internal */
-function getContexts() {
-	const scope = globalThis;
-	const all = scope[CONTEXTS] ??= /* @__PURE__ */ new WeakMap();
-	let contexts = all.get(React.createElement);
-	if (!contexts) {
-		contexts = {
-			graph: React.createContext(false),
-			render: React.createContext(null)
-		};
-		all.set(React.createElement, contexts);
-	}
-	return contexts;
-}
-function isElement(value) {
-	const type = value?.$$typeof;
-	return type === Symbol.for("react.transitional.element") || type === Symbol.for("react.element");
-}
-const slotStyle = { display: "contents" };
-/**
-* Splits props into what renders on the server and what travels: server output passed to an
-* island (`children`, or any element prop) renders once inside `<f-slot>`, and travels as a
-* reference to it, so the browser reads its HTML from the page instead of receiving it twice.
-*/
-function splitSlots(value, prefix, counter) {
-	if (isElement(value)) {
-		const name = `${prefix}${counter.next++}`;
-		const reference = {
-			["$"]: "s",
-			["v"]: name
-		};
-		runtimeTagged.add(reference);
-		return {
-			render: React.createElement(SLOT_ELEMENT, {
-				key: value.key ?? name,
-				name,
-				style: slotStyle
-			}, value),
-			wire: reference
-		};
-	}
-	if (Array.isArray(value)) {
-		const parts = value.map((entry) => splitSlots(entry, prefix, counter));
-		return {
-			render: parts.map((part) => part.render),
-			wire: parts.map((part) => part.wire)
-		};
-	}
-	if (value && typeof value === "object") {
-		const prototype = Object.getPrototypeOf(value);
-		if (prototype !== Object.prototype && prototype !== null) return {
-			render: value,
-			wire: value
-		};
-		const render = {};
-		const wire = {};
-		for (const [key, entry] of Object.entries(value)) {
-			const part = splitSlots(entry, prefix, counter);
-			render[key] = part.render;
-			wire[key] = part.wire;
-		}
-		return {
-			render,
-			wire
-		};
-	}
-	return {
-		render: value,
-		wire: value
-	};
-}
-const warned = /* @__PURE__ */ new Set();
-const outcomes = /* @__PURE__ */ new WeakMap();
-function settle(promise) {
-	let outcome = outcomes.get(promise);
-	if (!outcome) {
-		outcome = Promise.resolve(promise).then((value) => ({
-			ok: true,
-			value
-		}), (reason) => ({
-			ok: false,
-			reason
-		}));
-		outcomes.set(promise, outcome);
-	}
-	return outcome;
-}
-const REJECTED = "{\"e\":1}";
-/** Each promise an island received, in a boundary of its own: its outcome once it settles. */
-function promiseBoundaries(promises, label) {
-	return promises.map(({ name, promise }) => React.createElement(React.Suspense, {
-		key: name,
-		fallback: null
-	}, React.createElement(IslandPromise, {
-		name,
-		promise,
-		label
-	})));
-}
-/**
-* A promise's outcome, written when it settles. Its values are sent whether or not the page wrote
-* them already: this script may land before an earlier island's, wherever React puts it.
-*/
-function IslandPromise({ name, promise, label }) {
-	const outcome = React.use(settle(promise));
-	const state = React.useContext(getContexts().render) ?? resolveRenderState();
-	const hook = getIslandServerHook();
-	let encoded = {
-		json: REJECTED,
-		values: [],
-		promises: []
-	};
-	if (outcome.ok) try {
-		encoded = hook.encode({ v: outcome.value }, state?.held ?? null);
-	} catch (error) {
-		console.warn(`[islx] A promise passed to ${label} resolved to a value that cannot be sent to the browser: it rejects there.`, error);
-	}
-	else console.error(`[islx] A promise passed to ${label} rejected.`, outcome.reason);
-	return React.createElement(React.Fragment, null, ...encoded.values.map((value) => React.createElement("script", {
-		key: value.key,
-		type: VALUE_SCRIPT_TYPE,
-		name: value.key,
-		dangerouslySetInnerHTML: { __html: hook.escape(value.json) }
-	})), React.createElement("script", {
-		key: "outcome",
-		type: PROMISE_SCRIPT_TYPE,
-		name,
-		dangerouslySetInnerHTML: { __html: hook.escape(encoded.json) }
-	}), ...promiseBoundaries(encoded.promises, label));
-}
-function isThenable(value) {
-	return !!value && typeof value.then === "function";
-}
-/**
-* Wraps a client component so the server renders it as an island. `src` is the module the browser
-* imports, `exportName` the component's export there.
-*/
-function createIsland(Component, src, exportName, declared = "load", options = {}) {
-	function Island(props) {
-		const { graph, render } = getContexts();
-		const insideIsland = React.useContext(graph);
-		const state = React.useContext(render) ?? resolveRenderState();
-		const id = React.useId();
-		if (insideIsland) return React.createElement(Component, props);
-		const hook = getIslandServerHook();
-		if (!hook) throw new Error("islx: an island rendered on a server that did not import @farm.js/islx/react/server");
-		let encoded;
-		let renderProps;
-		let strategy = declared;
-		try {
-			const slots = { next: 0 };
-			const { render: rendered, wire } = splitSlots(props, `${id}s`, slots);
-			renderProps = rendered;
-			if (options.inferred && slots.next > 0) strategy = "load";
-			const skip = state ? /* @__PURE__ */ new Set([...state.held ?? [], ...state.sent]) : null;
-			encoded = hook.encode(wire, skip);
-			for (const value of encoded.values) state?.sent.add(value.key);
-		} catch (error) {
-			if (isThenable(error)) throw error;
-			const message = error instanceof Error ? error.message : String(error);
-			const key = `${src}#${exportName}:${message}`;
-			if (!warned.has(key)) {
-				warned.add(key);
-				console.warn(`[islx] ${exportName} (${src}) was rendered without hydration: its props cannot be sent to the browser. ${message}`);
-			}
-			return React.createElement(Component, props);
-		}
-		if (strategy === "load") {
-			const defaults = getBuildDefaults();
-			if (defaults.boot && defaults.entry) ReactDOM.preloadModule?.(defaults.entry, { as: "script" });
-			for (const href of defaults.modules?.[src] ?? []) ReactDOM.preloadModule?.(href, { as: "script" });
-		}
-		return React.createElement(React.Fragment, null, ...encoded.values.map((value) => React.createElement("script", {
-			key: value.key,
-			type: VALUE_SCRIPT_TYPE,
-			name: value.key,
-			dangerouslySetInnerHTML: { __html: hook.escape(value.json) }
-		})), React.createElement(ISLAND_ELEMENT, {
-			key: "island",
-			src,
-			export: exportName,
-			props: id,
-			strategy,
-			style: slotStyle
-		}, React.createElement(graph.Provider, { value: true }, React.createElement(Component, renderProps))), React.createElement("script", {
-			key: "props",
-			type: PROPS_SCRIPT_TYPE,
-			htmlFor: id,
-			dangerouslySetInnerHTML: { __html: hook.escape(encoded.json) }
-		}), ...promiseBoundaries(encoded.promises, `${exportName} (${src})`));
-	}
-	Island.displayName = `Island(${Component.displayName || Component.name || exportName})`;
-	Object.defineProperty(Island, CLIENT_REFERENCE, { value: {
-		src,
-		exportName,
-		Component
-	} });
-	return Island;
-}
-export { getIslandServerHook as a, setIslandServerHook as c, getContexts as i, setRenderStateResolver as l, createIsland as n, isolateIslands as o, getClientReference as r, runtimeTagged as s, IslandsProvider as t, withinClientRoot as u };