@farm.js/islx 0.0.4 → 0.0.6

package/dist/tanstack-start/server.mjs

@@ -0,0 +1,54 @@
+import { t as IslandsProvider } from "../_chunks/island-DVOr-OUw.mjs";
+import { A as VALUES_HEADER, C as RENDER_HEADER } from "../_chunks/wire-QEQWBr5s.mjs";
+import { a as parseHeldValues } from "../_chunks/values-37UIzxM0.mjs";
+import * as React from "react";
+import { StartServer } from "@tanstack/react-start/server";
+import { createSsrStreamResponse, defineHandlerCallback, getSsrStatus, renderRouterToStream, transformReadableStreamWithRouter } from "@tanstack/react-router/ssr/server";
+// src/tanstack-start/server.ts
+/**
+* @farm.js/islx/tanstack-start/server: the render handler of a TanStack Start app as islands.
+* `islxTanstackStart()` uses it for Start's default server entry; an app with its own
+* `src/server.ts` passes it to `createStartHandler`:
+*
+*   import { createServerEntry, createStartHandler } from "@tanstack/react-start/server";
+*   import { islandsHandler } from "@farm.js/islx/tanstack-start/server";
+*   export default createServerEntry({ fetch: createStartHandler(islandsHandler) });
+*/
+/**
+* Renders the page with its islands: values the browser holds stay out, and a navigation (an
+* `F-Render` request) gets the whole page in one piece, as islx's browser runtime swaps it in.
+*/
+const islandsHandler = defineHandlerCallback(({ request, router, responseHeaders }) => {
+	const held = parseHeldValues(request);
+	responseHeaders.append("Vary", `${VALUES_HEADER}, ${RENDER_HEADER}`);
+	if (held.size > 0) responseHeaders.set("Cache-Control", "private, no-store");
+	const children = React.createElement(IslandsProvider, { held }, React.createElement(StartServer, { router }));
+	if (!request.headers.has("F-Render")) return renderRouterToStream({
+		request,
+		router,
+		responseHeaders,
+		children
+	});
+	return renderWhole(request, router, responseHeaders, children);
+});
+/** Waits for every Suspense boundary, so React writes the page with no streaming scripts. */
+async function renderWhole(request, router, responseHeaders, children) {
+	const { renderToReadableStream } = await import("react-dom/server");
+	const stream = await renderToReadableStream(children, {
+		signal: request.signal,
+		nonce: router.options.ssr?.nonce,
+		onError(error) {
+			if (!request.signal.aborted) console.error("Error in renderToReadableStream:", error);
+		}
+	});
+	await stream.allReady;
+	const body = transformReadableStreamWithRouter(router, stream, {
+		rendererSafePoint: "script-close",
+		signal: request.signal
+	});
+	return createSsrStreamResponse(router, new Response(body, {
+		status: getSsrStatus(router),
+		headers: responseHeaders
+	}));
+}
+export { islandsHandler };

package/dist/tanstack-start.d.mts

@@ -0,0 +1,8 @@
+import { IslxOptions } from "./vite.mjs";
+import { Plugin } from "vite";
+
+// src/tanstack-start/index.d.ts
+
+type IslxTanstackStartOptions = IslxOptions;
+declare function islxTanstackStart(options?: IslxTanstackStartOptions): Plugin[];
+export { IslxTanstackStartOptions, islxTanstackStart as default, islxTanstackStart };

package/dist/tanstack-start.mjs

@@ -0,0 +1,100 @@
+import { n as islx, t as ENTRY_ID } from "./_chunks/vite-BTzYlEiY.mjs";
+import { normalizePath } from "vite";
+// src/tanstack-start/index.ts
+/**
+* @farm.js/islx/tanstack-start: a TanStack Start app as islands.
+*
+*   import { tanstackStart } from "@tanstack/react-start/plugin/vite";
+*   import { islxTanstackStart } from "@farm.js/islx/tanstack-start";
+*   export default defineConfig({ plugins: [tanstackStart(), react(), islxTanstackStart()] });
+*
+* Routes render on the server; the browser loads islx and the `"use client"` components a page
+* uses, not the router or the routes. TanStack Start's client entry becomes islx's browser entry,
+* so `<Scripts />` still loads it. Client components are the `"use client"` modules under `src/`
+* (`clientComponents.include`); a library's stay server HTML.
+*/
+const START_CLIENT_ENTRY = "virtual:tanstack-start-client-entry";
+const START_SERVER_ENTRY = "virtual:tanstack-start-server-entry";
+const START_ROUTER_ENTRY = "#tanstack-router-entry";
+const ROUTER_WRAPPER = "\0islx:tanstack-router";
+const SERVER_WRAPPER = "\0islx:tanstack-server-entry";
+const SERVER_ENTRY = `import { createServerEntry, createStartHandler } from "@tanstack/react-start/server";
+import { handleAction } from "@farm.js/islx/server";
+import { islandsHandler } from "@farm.js/islx/tanstack-start/server";
+const start = createStartHandler(islandsHandler);
+export default createServerEntry({
+  // islx's server actions first; any other request (and Start's server functions) goes to Start.
+  async fetch(request, ...rest) {
+    return (await handleAction(request)) ?? start(request, ...rest);
+  },
+});
+`;
+const routerWrapper = (routerPath) => `import * as app from ${JSON.stringify(routerPath)};
+import { PREHYDRATION_SCRIPT } from "@farm.js/islx/client";
+export * from ${JSON.stringify(routerPath)};
+const islxHead = new WeakSet();
+export async function getRouter(...args) {
+  const router = await app.getRouter(...args);
+  const lifecycle = (router.serverSsrLifecycle ??= {});
+  // Start dehydrates every request: here that turns hydration off instead.
+  (lifecycle.onServerSsrAttach ??= []).push((ssr) => {
+    ssr.dehydrate = async () => ssr.disableHydration();
+  });
+  const root = router.routeTree;
+  if (root && !islxHead.has(root)) {
+    islxHead.add(root);
+    const head = root.options.head;
+    const add = (own) => ({ ...own, scripts: [{ children: PREHYDRATION_SCRIPT }, ...(own?.scripts ?? [])] });
+    root.options.head = (context) => {
+      const own = head?.(context);
+      return own && typeof own.then === "function" ? own.then(add) : add(own);
+    };
+  }
+  return router;
+}
+`;
+function islxTanstackStart(options = {}) {
+	let clientEntry;
+	let serverEntry;
+	let routerEntry;
+	const pathOf = (id) => normalizePath(id.split("?", 1)[0]);
+	return [{
+		name: "islx:tanstack-start",
+		enforce: "pre",
+		configResolved(config) {
+			const aliasOf = (find) => {
+				const alias = config.resolve.alias.find((entry) => entry.find === find);
+				if (!alias) throw new Error("islx: add tanstackStart() from @tanstack/react-start/plugin/vite before islxTanstackStart()");
+				return normalizePath(alias.replacement);
+			};
+			clientEntry = aliasOf(START_CLIENT_ENTRY);
+			routerEntry = aliasOf(START_ROUTER_ENTRY);
+			const server = aliasOf(START_SERVER_ENTRY);
+			if (server.includes("/node_modules/") || server.includes("/@tanstack/")) serverEntry = server;
+		},
+		resolveId(id, importer) {
+			if (this.environment.name === "client" || !routerEntry) return void 0;
+			if (serverEntry && pathOf(id) === serverEntry) return SERVER_WRAPPER;
+			if (!importer) return void 0;
+			if (pathOf(id) === routerEntry && importer !== ROUTER_WRAPPER && importer.includes("@tanstack")) return ROUTER_WRAPPER;
+		},
+		load(id) {
+			if (id === ROUTER_WRAPPER) return routerWrapper(routerEntry);
+			if (id === SERVER_WRAPPER) return SERVER_ENTRY;
+			const file = pathOf(id);
+			if (this.environment.name === "client") return file === clientEntry ? `import ${JSON.stringify(ENTRY_ID)};` : void 0;
+		}
+	}, ...islx({
+		serverEnvironments: ["ssr"],
+		...options,
+		clientComponents: {
+			include: options.clientComponents?.include ?? ["src/**"],
+			exclude: ["**/node_modules/**", ...options.clientComponents?.exclude ?? []]
+		}
+	}, {
+		frameworkEntry: true,
+		frameworkBuild: true,
+		frameworkRender: true
+	})];
+}
+export { islxTanstackStart as default, islxTanstackStart };

package/dist/vite.d.mts

@@ -43,6 +43,8 @@ interface IslxOptions {
     server?: string | ServerHooks;
   };
 }
+/** @internal The browser entry, for a framework whose own entry imports it. */
+declare const ENTRY_ID = "virtual:islx/client-entry";
 /**
  * The source of a hooks module made from callbacks. Each callback is copied as written, so it
  * must not use anything from where it was written: an outside variable, an import.
@@ -53,5 +55,22 @@ declare function resolveDirectives(directives?: IslxOptions["directives"]): {
   client: string;
   server: string;
 };
-declare function islx(options?: IslxOptions): Plugin[];
-export { IslxOptions, islx as default, islx, resolveDirectives, serializeHooks };
+/**
+ * @internal How a framework integration hosts islx (`@farm.js/islx/tanstack-start`).
+ */
+interface IslxHost {
+  /** The framework's own client entry imports islx's, so islx adds no browser entry of its own. */
+  frameworkEntry?: boolean;
+  /**
+   * The framework renders pages itself, without `renderToStream`: the server runtime islands need
+   * loads with them.
+   */
+  frameworkRender?: boolean;
+  /**
+   * The framework orders the build (the browser before the server): client modules come from
+   * `clientComponents.include`, and the server build gets their files directly.
+   */
+  frameworkBuild?: boolean;
+}
+declare function islx(options?: IslxOptions, host?: IslxHost): Plugin[];
+export { ENTRY_ID, IslxHost, IslxOptions, islx as default, islx, resolveDirectives, serializeHooks };