@void/react 0.0.0

package/dist/plugin.mjs

@@ -0,0 +1,553 @@
+import react from "@vitejs/plugin-react";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { normalizePath } from "vite";
+import { generateComponentManifest, resolveEffectiveLayoutChain, resolveStaticPageDataBuildOptions, scanPages } from "void/pages";
+import { ISLANDS_CLIENT_ENTRY_ID, ISLANDS_RENDERER_ID, computePagesNeedingClientJS, configureIslandCssServer, extractCssImports, fileHasCssImports, needsIslandClientBundle, rebuildIslandCssMap, resolveSpecifier, rewriteCssImportForVirtualModule, watchPagesForRescan } from "void/pages-islands-plugin";
+//#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+const normalize = function(path) {
+	if (path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
+		if (isPathAbsolute) return "/";
+		return trailingSeparator ? "./" : ".";
+	}
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
+	if (isUNCPath) {
+		if (!isPathAbsolute) return `//./${path}`;
+		return `//${path}`;
+	}
+	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...segments) {
+	let path = "";
+	for (const seg of segments) {
+		if (!seg) continue;
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/";
+			const segLeading = seg[0] === "/";
+			if (pathTrailing && segLeading) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
+	}
+	return normalize(path);
+};
+function cwd() {
+	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
+	return "/";
+}
+const resolve = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd();
+		if (!path || path.length === 0) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+const relative = function(from, to) {
+	const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) return _to.join("/");
+	const _fromCopy = [..._from];
+	for (const segment of _fromCopy) {
+		if (_to[0] !== segment) break;
+		_from.shift();
+		_to.shift();
+	}
+	return [..._from.map(() => ".."), ..._to].join("/");
+};
+const dirname = function(p) {
+	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
+	return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+//#endregion
+//#region src/plugin-islands.ts
+const COMPONENT_EXTENSIONS = [
+	".tsx",
+	".jsx",
+	".ts",
+	".js"
+];
+function islandsPlugin(pagesDir) {
+	let pageScan = null;
+	let isDev = false;
+	const root = dirname(pagesDir);
+	const islandManifest = /* @__PURE__ */ new Map();
+	const islandCssFiles = /* @__PURE__ */ new Set();
+	let viteRoot = "";
+	const islandCssMap = /* @__PURE__ */ new Map();
+	let resolvedConfig = null;
+	/** Rebuild islandCssMap from current file contents (re-runs fileHasCssImports). */
+	function rebuildCssMapLocal() {
+		if (!pageScan) return;
+		rebuildIslandCssMap(pageScan, pagesDir, islandCssMap, fileHasCssImports);
+	}
+	function computePagesNeedingClientJSLocal() {
+		if (!pageScan) return /* @__PURE__ */ new Set();
+		return computePagesNeedingClientJS(pageScan, pagesDir, resolvedConfig);
+	}
+	return [{
+		name: "void-react:islands",
+		configResolved(config) {
+			resolvedConfig = config;
+			viteRoot = config.root;
+			isDev = config.command === "serve";
+		},
+		configureServer(server) {
+			configureIslandCssServer(server, islandCssFiles, viteRoot, rebuildCssMapLocal);
+			watchPagesForRescan(server, pagesDir, root, (scan) => {
+				pageScan = scan;
+				rebuildCssMapLocal();
+			});
+		},
+		async buildStart() {
+			if (existsSync(pagesDir)) {
+				pageScan = await scanPages(root);
+				const importAttrRe = /import\s+\w+\s+from\s+("[^"]+"|'[^']+')\s+with\s*\{\s*island\s*:\s*("[^"]+"|'[^']+')\s*\}/g;
+				const filesToScan = [
+					...pageScan.pages.map((p) => ({
+						filePath: p.componentPath,
+						island: p.island
+					})),
+					...pageScan.layouts.map((l) => ({
+						filePath: l.filePath,
+						island: l.island
+					})),
+					...pageScan.namedLayouts.map((nl) => ({
+						filePath: nl.filePath,
+						island: nl.island
+					}))
+				];
+				for (const entry of filesToScan) {
+					if (!entry.island) continue;
+					const filePath = resolve(pagesDir, entry.filePath);
+					const code = readFileSync(filePath, "utf-8");
+					const importerDir = dirname(filePath);
+					importAttrRe.lastIndex = 0;
+					let m;
+					while ((m = importAttrRe.exec(code)) !== null) {
+						const spec = m[1].slice(1, -1);
+						const strategy = m[2].slice(1, -1);
+						const absPath = resolveSpecifier(spec, importerDir, COMPONENT_EXTENSIONS);
+						if (absPath) {
+							const islandId = normalizePath(relative(root, absPath)).replace(/\.[^.]+$/, "");
+							islandManifest.set(islandId, {
+								componentPath: absPath,
+								islandId,
+								hydrate: strategy
+							});
+						}
+					}
+				}
+				for (const page of pageScan.pages) {
+					if (!page.island) continue;
+					if (/\.(tsx|jsx)$/.test(page.componentPath)) islandCssFiles.add(normalizePath(resolve(pagesDir, page.componentPath)));
+					const layoutChain = resolveEffectiveLayoutChain(page, pageScan.layouts, pageScan.namedLayouts);
+					for (const layout of layoutChain) islandCssFiles.add(normalizePath(resolve(pagesDir, layout.filePath)));
+				}
+				rebuildCssMapLocal();
+			}
+		},
+		resolveId: {
+			filter: { id: /^virtual:void-islands-(renderer|client)$|\.(tsx|jsx)\.css$/ },
+			handler(source) {
+				if (source === ISLANDS_RENDERER_ID || source === ISLANDS_CLIENT_ENTRY_ID) return "\0" + source;
+				if (source.endsWith(".css")) {
+					const srcPath = normalizePath(source.slice(0, -4));
+					if (islandCssFiles.has(srcPath)) return srcPath + ".css";
+					if (srcPath.startsWith("/")) {
+						const absPath = normalizePath(resolve(viteRoot, srcPath.slice(1)));
+						if (islandCssFiles.has(absPath)) return absPath + ".css";
+					}
+				}
+			}
+		},
+		load: {
+			filter: { id: /^\0virtual:void-islands-(renderer|client)$|\.(tsx|jsx)\.css$/ },
+			handler(id) {
+				if (id === "\0" + ISLANDS_RENDERER_ID) {
+					if (!pageScan) return "export function renderIslandPage() { throw new Error('No pages found'); }";
+					const mdPlugin = resolvedConfig?.plugins?.find((p) => p.name === "void-md");
+					const mdScriptIds = new Set(mdPlugin?.api?.getClientScripts?.()?.keys() ?? []);
+					const needsJS = computePagesNeedingClientJSLocal();
+					return generateIslandRenderer(pageScan, pagesDir, isDev, islandCssMap, viteRoot, mdScriptIds, needsJS);
+				}
+				if (id === "\0" + ISLANDS_CLIENT_ENTRY_ID) {
+					if (!pageScan) return "";
+					return generateIslandClientEntry(islandManifest, islandCssFiles, isDev);
+				}
+				if (id.endsWith(".css") && !id.startsWith("\0")) {
+					const srcPath = id.slice(0, -4);
+					if (islandCssFiles.has(srcPath)) return extractCssImports(srcPath);
+				}
+			}
+		},
+		transform: {
+			filter: { id: /\.island\.(tsx|jsx)$/ },
+			handler(code, id) {
+				if (/import\s+\{[^}]*\buseForm\b/.test(code)) this.warn(`islands: useForm cannot be imported in island page '${id}'. Use useIslandForm instead.`);
+				const importAttrRe = /import\s+(\w+)\s+from\s+("[^"]+"|'[^']+')\s+with\s*\{\s*island\s*:\s*("[^"]+"|'[^']+')\s*\}/g;
+				const importerDir = dirname(id);
+				let transformed = code;
+				const wrappers = [];
+				let idx = 0;
+				let match;
+				while ((match = importAttrRe.exec(code)) !== null) {
+					const name = match[1];
+					const specRaw = match[2];
+					const strategyRaw = match[3];
+					const spec = specRaw.slice(1, -1);
+					const strategy = strategyRaw.slice(1, -1);
+					const rawName = `_raw_island_${idx++}`;
+					const absPath = resolveSpecifier(spec, importerDir, COMPONENT_EXTENSIONS);
+					if (absPath) {
+						const islandId = normalizePath(relative(root, absPath)).replace(/\.[^.]+$/, "");
+						islandManifest.set(islandId, {
+							componentPath: absPath,
+							islandId,
+							hydrate: strategy
+						});
+					}
+					const islandId = absPath ? normalizePath(relative(root, absPath)).replace(/\.[^.]+$/, "") : spec;
+					const replacement = `import ${rawName} from ${specRaw}`;
+					transformed = transformed.replace(match[0], replacement);
+					wrappers.push(`var ${name} = function ${name}(props) { return _React_island.createElement("div", { "data-island": ${JSON.stringify(islandId)}, "data-props": JSON.stringify(props), "data-hydrate": ${JSON.stringify(strategy)} }, _React_island.createElement(${rawName}, props)); };`);
+				}
+				if (wrappers.length > 0) {
+					transformed = `import _React_island from "react";\n` + transformed + "\n" + wrappers.join("\n");
+					return {
+						code: transformed,
+						map: null
+					};
+				}
+			}
+		},
+		config(_, env) {
+			if (!existsSync(pagesDir)) return;
+			if (env.command !== "serve" && needsIslandClientBundle(pagesDir, /\.island\.(tsx|jsx)$/, false)) return { build: {
+				manifest: true,
+				rollupOptions: { input: { "islands-client": ISLANDS_CLIENT_ENTRY_ID } }
+			} };
+		}
+	}];
+}
+function generateIslandRenderer(scan, pagesDir, isDev, islandCssMap, viteRoot, mdScriptIds, pagesNeedingClientJS) {
+	const preambleScript = isDev ? `
+<script type="module">
+  import RefreshRuntime from "/@react-refresh"
+  RefreshRuntime.injectIntoGlobalHook(window)
+  window.$RefreshReg$ = () => {}
+  window.$RefreshSig$ = () => (type) => type
+  window.__vite_plugin_react_preamble_installed__ = true
+<\/script>` : "";
+	let cssMapCode = "";
+	if (isDev && islandCssMap.size > 0) {
+		const cssMapObj = {};
+		for (const [compId, paths] of islandCssMap) cssMapObj[compId] = paths.map((p) => "/" + normalizePath(relative(viteRoot, p)) + ".css");
+		cssMapCode = `const __cssPaths = ${JSON.stringify(cssMapObj)};`;
+	}
+	const mdScriptIdsCode = `const __mdClientScriptIds = new Set(${JSON.stringify([...mdScriptIds])});`;
+	const needsJSCode = `const __pagesNeedingClientJS = new Set(${JSON.stringify([...pagesNeedingClientJS])});`;
+	return `
+import React from "react";
+import { renderToString } from "react-dom/server";
+import { SharedContext, ErrorsContext } from "@void/react";
+import { renderHeadToString, renderHtmlAttrs, renderBodyAttrs } from "void/pages-head";
+
+${generateComponentManifest(scan, pagesDir)}
+${cssMapCode}
+${mdScriptIdsCode}
+${needsJSCode}
+
+const PREAMBLE_SCRIPT = ${JSON.stringify(preambleScript)};
+
+function escapeAttr(s) {
+  return String(s).replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+
+export async function renderIslandPage(pageObj, assetTags) {
+  const PageComponent = (await components[pageObj.component]()).default;
+  const layoutIds = layoutTree[pageObj.component] || [];
+  const layoutComponents = await Promise.all(
+    layoutIds.map(async (id) => (await components[id]()).default)
+  );
+
+  let element = React.createElement(PageComponent, pageObj.props);
+  for (let i = layoutComponents.length - 1; i >= 0; i--) {
+    element = React.createElement(layoutComponents[i], null, element);
+  }
+
+  // No RouterContext — islands have no Void Router
+  element = React.createElement(
+    SharedContext.Provider,
+    { value: pageObj.shared || {} },
+    React.createElement(
+      ErrorsContext.Provider,
+      { value: pageObj.errors || {} },
+      element
+    )
+  );
+
+  const html = renderToString(element);
+  const __mdScriptAttr = __mdClientScriptIds.has(pageObj.component) ? \` data-md-script="\${escapeAttr(pageObj.component)}"\` : "";
+  const headHtml = pageObj.head ? renderHeadToString(pageObj.head) : "";
+  const htmlAttrs = pageObj.head ? renderHtmlAttrs(pageObj.head) : "";
+  const bodyAttrs = pageObj.head ? renderBodyAttrs(pageObj.head) : "";
+
+  return \`<!doctype html>
+<html\${htmlAttrs}>
+<head>\${headHtml}\${typeof __cssPaths !== "undefined" ? (__cssPaths[pageObj.component] || []).map(url => '<link rel="stylesheet" href="' + url + '">').join("\\n") : ""}\${PREAMBLE_SCRIPT}\${assetTags.css}\${__pagesNeedingClientJS.has(pageObj.component) ? assetTags.preloads : ""}</head>
+<body\${bodyAttrs}>
+  <div id="app"\${__mdScriptAttr}>\${html}</div>
+  \${__pagesNeedingClientJS.has(pageObj.component) ? assetTags.body : ""}
+</body>
+</html>\`;
+}
+`;
+}
+function generateIslandClientEntry(manifest, cssFiles, isDev) {
+	const entries = [...manifest.values()];
+	const uniqueIslands = /* @__PURE__ */ new Map();
+	for (const entry of entries) uniqueIslands.set(entry.islandId, entry.componentPath);
+	const lines = [];
+	lines.push("import { initIslands } from \"void/pages-client\";");
+	if (!isDev) {
+		const cssImportRe = /^\s*import\b[^"']*["']([^"']+\.(?:css|scss|sass|less|styl|stylus|pcss|postcss))["']/gm;
+		for (const file of cssFiles) {
+			const content = readFileSync(file, "utf-8");
+			cssImportRe.lastIndex = 0;
+			let match;
+			while ((match = cssImportRe.exec(content)) !== null) lines.push(rewriteCssImportForVirtualModule(match[0], match[1], file));
+		}
+	}
+	lines.push("const islands = {");
+	for (const [id, path] of uniqueIslands) lines.push(`  ${JSON.stringify(id)}: () => import(${JSON.stringify(path)}),`);
+	lines.push("};");
+	lines.push(`
+async function hydrateIsland(el, mod, props) {
+  const { hydrateRoot } = await import("react-dom/client");
+  const React = await import("react");
+  const Component = mod.default || mod;
+  hydrateRoot(el, React.createElement(Component, props));
+  el.setAttribute("data-hydrated", "true");
+}
+
+initIslands(islands, hydrateIsland);
+`);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/plugin-pages.ts
+const RENDERER_ID = "virtual:void-pages-renderer";
+const CLIENT_ENTRY_ID = "virtual:void-pages-client";
+/** Check if the pages directory has any non-island page files (.tsx/.jsx without .island.). */
+function hasNonIslandPages(dir) {
+	try {
+		for (const entry of readdirSync(dir, {
+			withFileTypes: true,
+			recursive: true
+		})) {
+			if (!entry.isFile()) continue;
+			const name = entry.name;
+			if (name.startsWith("_") || name.startsWith("layout.")) continue;
+			if (/\.(tsx|jsx)$/.test(name) && !name.includes(".island.")) return true;
+		}
+	} catch {}
+	return false;
+}
+function pagesPlugin(pagesDir, options) {
+	let pageScan = null;
+	let isDev = false;
+	let viteConfig;
+	const root = dirname(pagesDir);
+	return {
+		name: "void-react:pages",
+		async buildStart() {
+			if (existsSync(pagesDir)) pageScan = await scanPages(root);
+		},
+		resolveId: {
+			filter: { id: /^virtual:void-pages-(renderer|client)$/ },
+			handler(id) {
+				return "\0" + id;
+			}
+		},
+		load: {
+			filter: { id: /^\0virtual:void-pages-(renderer|client)$/ },
+			handler(id) {
+				if (id === "\0" + RENDERER_ID) {
+					if (!pageScan) return "export function renderPage() { throw new Error('No pages found'); }";
+					return generateRendererModule(pageScan, pagesDir, isDev);
+				}
+				if (id === "\0" + CLIENT_ENTRY_ID) {
+					if (!pageScan) return "";
+					return generateClientEntry(pageScan, pagesDir, options?.viewTransitions, options?.prefetch, resolveStaticPageDataBuildOptions(root, { publicDir: viteConfig?.publicDir }));
+				}
+			}
+		},
+		configResolved(config) {
+			viteConfig = config;
+		},
+		config(_, env) {
+			if (!existsSync(pagesDir)) return;
+			if (env.command === "serve") {
+				isDev = true;
+				const reactOptimizeDeps = [
+					"react",
+					"react/jsx-runtime",
+					"react/jsx-dev-runtime",
+					"react-dom",
+					"react-dom/client",
+					"react-dom/server"
+				];
+				return {
+					optimizeDeps: {
+						exclude: ["@void/react"],
+						include: reactOptimizeDeps
+					},
+					ssr: { optimizeDeps: { include: reactOptimizeDeps } }
+				};
+			}
+			if (!hasNonIslandPages(pagesDir)) return;
+			return { build: {
+				manifest: true,
+				rollupOptions: { input: { "pages-client": CLIENT_ENTRY_ID } }
+			} };
+		}
+	};
+}
+function generateRendererModule(scan, pagesDir, isDev) {
+	const preambleScript = isDev ? `
+<script type="module">
+  import RefreshRuntime from "/@react-refresh"
+  RefreshRuntime.injectIntoGlobalHook(window)
+  window.$RefreshReg$ = () => {}
+  window.$RefreshSig$ = () => (type) => type
+  window.__vite_plugin_react_preamble_installed__ = true
+<\/script>` : "";
+	return `
+import { renderReactPage } from "@void/react/pages-server";
+
+${generateComponentManifest(scan, pagesDir)}
+
+	const PREAMBLE_SCRIPT = ${JSON.stringify(preambleScript)};
+	
+	export async function renderPage(pageObj, assetTags) {
+	  return renderReactPage({
+	    pageObj,
+	    assetTags,
+	    components,
+	    layoutTree,
+	    preambleScript: PREAMBLE_SCRIPT,
+	  });
+}
+`;
+}
+function generateClientEntry(scan, pagesDir, viewTransitions, prefetch, staticPageData) {
+	return `
+	import { startReactPages } from "@void/react/pages-client";
+	import { parseCacheFor } from "void/pages-prefetch";
+	
+	${generateComponentManifest(scan, pagesDir)}
+
+	const { router } = await startReactPages({
+	  components,
+	  layoutTree,
+	  routeMeta,
+	  matchRoute,
+	  staticPageData: ${!!staticPageData?.enabled},
+	  staticPageDataFastPath: ${!!staticPageData?.fastPath},
+	  viewTransitions: ${!!viewTransitions},
+	  prefetchHoverDelay: ${prefetch?.hoverDelay ?? 75},
+	  prefetchDefaultCacheFor: parseCacheFor(${JSON.stringify(prefetch?.cacheFor ?? "30s")}),
+	});
+	export { router };
+	`;
+}
+//#endregion
+//#region src/plugin.ts
+function voidReact(options) {
+	const pagesDir = join(process.cwd(), "pages");
+	return [
+		...react(options?.react),
+		pagesPlugin(pagesDir, {
+			viewTransitions: options?.viewTransitions,
+			prefetch: options?.prefetch
+		}),
+		...islandsPlugin(pagesDir)
+	];
+}
+//#endregion
+export { voidReact };

package/dist/runtime/index.d.mts

@@ -0,0 +1,2 @@
+import { a as RouterContext, c as setActionRouter, d as useForm, f as useShared, i as NavigationContext, l as useIslandForm, m as Link, n as InferProps, o as SharedContext, p as useRouter, r as ErrorsContext, s as action, t as Deferred, u as useNavigation } from "../index-6hxGVqsE.mjs";
+export { Deferred, ErrorsContext, InferProps, Link, NavigationContext, RouterContext, SharedContext, action, setActionRouter, useForm, useIslandForm, useNavigation, useRouter, useShared };

package/dist/runtime/index.mjs

@@ -0,0 +1,4 @@
+import { i as SharedContext, n as NavigationContext, r as RouterContext, t as ErrorsContext } from "../context-BCeFV8Jy.mjs";
+import { a as useRouter, i as useShared, n as useNavigation, o as Link, r as useForm, t as useIslandForm } from "../runtime-C24S_Dlg.mjs";
+import { n as setActionRouter, t as action } from "../action-BFWtavbf.mjs";
+export { ErrorsContext, Link, NavigationContext, RouterContext, SharedContext, action, setActionRouter, useForm, useIslandForm, useNavigation, useRouter, useShared };

package/dist/runtime/pages-client.d.mts

@@ -0,0 +1,27 @@
+import { ComponentType } from "react";
+import { VoidRouter } from "void/pages-client";
+import { CacheForResult } from "void/pages-prefetch";
+
+//#region src/runtime/pages-client.d.ts
+type ComponentModule = {
+  default: ComponentType<any>;
+};
+interface ReactPagesConfig {
+  components: Record<string, () => Promise<ComponentModule>>;
+  layoutTree: Record<string, Array<string>>;
+  routeMeta: Record<string, {
+    island?: boolean;
+  }>;
+  matchRoute(url: string): string | null;
+  staticPageData: boolean;
+  staticPageDataFastPath: boolean;
+  viewTransitions: boolean;
+  prefetchHoverDelay: number;
+  prefetchDefaultCacheFor: CacheForResult;
+}
+interface ReactPagesClient {
+  router: VoidRouter;
+}
+declare function startReactPages(config: ReactPagesConfig): Promise<ReactPagesClient>;
+//#endregion
+export { ReactPagesClient, ReactPagesConfig, startReactPages };