@octanejs/vite-plugin 0.1.5 → 0.1.6

package/src/project-codegen.js

@@ -1,218 +1,10 @@
-// @ts-check
-/** @import { ResolvedConfig } from 'vite' */
-
-import fs from 'node:fs';
-import path from 'node:path';
-
-export const RESOLVED_ADAPTER_BROWSER_STUB_ID = '\0octane:adapter-browser-stub';
-// Server-only deploy/adapter packages: client-side imports of these specifiers
-// resolve to the browser stub below instead of the real module (whose graph
-// pulls node builtins). Every published adapter package MUST be listed here,
-// and its public exports added to the stub.
-export const SERVER_ONLY_ADAPTER_IDS = new Set([
-	'@ripple-ts/adapter-node',
-	'@ripple-ts/adapter-bun',
-	'@ripple-ts/adapter-vercel',
-	'@octanejs/adapter-vercel',
-]);
-
-/** @type {Map<string, string>} */
-const generated_file_cache = new Map();
-
-/**
- * The browser stand-in shared by every SERVER_ONLY_ADAPTER_IDS package — it
- * must export the UNION of their public names, each failing loudly on use
- * (never at import, so merely reaching the module keeps the app alive).
- * @returns {string}
- */
-export function create_adapter_browser_stub_source() {
-	return `export const runtime = undefined;
-export function serve() {
-  throw new Error('[octane] Server adapters cannot run in the browser.');
-}
-export function nodeRequestToWebRequest() {
-  throw new Error('[octane] Node request helpers cannot run in the browser.');
-}
-export function webResponseToNodeResponse() {
-  throw new Error('[octane] Node response helpers cannot run in the browser.');
-}
-export function vercel() {
-  throw new Error('[octane] Deploy adapters cannot run in the browser.');
-}
-export function adapt() {
-  throw new Error('[octane] Deploy adapters cannot run in the browser.');
-}
-`;
-}
-
-/**
- * @param {ResolvedConfig} viteConfig
- * @returns {string}
- */
-export function get_project_generated_dir(viteConfig) {
-	return path.join(viteConfig.cacheDir, 'project');
-}
-
-/**
- * @param {ResolvedConfig} viteConfig
- * @param {string} name
- * @param {string} source
- * @returns {string}
- */
-export function write_project_generated_file(viteConfig, name, source) {
-	const dir = get_project_generated_dir(viteConfig);
-	const file = path.join(dir, name);
-
-	if (generated_file_cache.get(file) === source && fs.existsSync(file)) {
-		return file;
-	}
-
-	fs.mkdirSync(dir, { recursive: true });
-	if (!fs.existsSync(file) || fs.readFileSync(file, 'utf-8') !== source) {
-		fs.writeFileSync(file, source);
-	}
-	generated_file_cache.set(file, source);
-	return file;
-}
-
-/**
- * Generate the client hydration entry (served at virtual:octane-hydrate).
- *
- * CONFIG-FREE: it does NOT import octane.config.ts. Importing the config into
- * the browser would drag the plugin (and the server adapter) — with their
- * `node:fs` imports — into the client graph and throw at module-eval. Instead
- * the server serializes everything needed into #__octane_data ({ entry,
- * exportName, layout, params, url, preHydrate }), and this entry
- * dynamic-imports the page/layout from there.
- *
- * `staticEntries` (production builds) lists every module path the server can
- * name in #__octane_data — page entries, layouts, and the preHydrate hook.
- * Each becomes a STATIC `() => import('/src/…')` in a lookup map, so Rollup
- * sees, chunks, and hashes them; the runtime falls back to the hidden dynamic
- * import only for paths outside the map (the dev case, where the map is empty
- * and Vite serves any module by URL).
- *
- * octane specifics:
- *   - `import { hydrateRoot } from 'octane'` (NO `mount`).
- *   - `hydrateRoot(container, body, props)` signature (container FIRST, React-18
- *     shape) — no `{ target, props }` wrapper.
- *   - The layout `children` is a ComponentBody `(s) => Page(s, { params })`,
- *     NOT a 0-arg thunk: octane's `childSlot` invokes a bare function child
- *     as a ComponentBody (block first arg, `{}` props), so page data rides the
- *     closure — mirroring the server `createLayoutWrapper`.
- *   - hydrateRoot() itself locates/consumes the <script data-octane-suspense>
- *     seed inside #root, so the entry does nothing special for suspense.
- *   - `preHydrate` (config `router.preHydrate`, a Vite-root module path) is
- *     imported and its default export awaited BEFORE hydrateRoot — the hook an
- *     app-level client router uses to commit its match tree so the first
- *     hydration pass adopts the same resolved tree the server rendered.
- *
- * `getComponentExport` mirrors routes.js `get_component_export` (route named
- * export > default > first PascalCase) so server and client pick the SAME
- * component.
- *
- * @param {{ configPath?: string, staticEntries?: string[] }} [options]
- * @returns {string}
- */
-export function create_client_entry_source(options = {}) {
-	const staticEntries = [...new Set(options.staticEntries ?? [])];
-	const static_map_lines = staticEntries
-		.map((entry) => `  ${JSON.stringify(entry)}: () => import(${JSON.stringify(entry)}),`)
-		.join('\n');
-
-	return `// Auto-generated by @octanejs/vite-plugin.
-// This file is written to Vite's cacheDir/project folder.
-
-import { hydrateRoot } from 'octane';
-
-// Static import map (production): every module the server may name in
-// #__octane_data, as bundle-analyzable dynamic imports. Empty in dev.
-const routeModules = {
-${static_map_lines}
-};
-
-// Dynamic import Vite's import-analysis can NOT see: its rewrite appends
-// '?import' to variable dynamic imports, and a queried URL evaluates as a
-// SECOND browser module instance — so the page (or the preHydrate hook) would
-// no longer share module singletons with statically-imported copies of the
-// same files (e.g. a client router the app also imports directly).
-const dynamicImport = new Function('specifier', 'return import(specifier)');
-
-function importModule(path) {
-  const loader = routeModules[path];
-  return loader ? loader() : dynamicImport(path);
-}
-
-function getComponentExport(module, exportName) {
-  // Explicit export name requires an exact match; do NOT fall back, so a
-  // typo'd route renders nothing rather than the wrong component.
-  if (exportName) return typeof module[exportName] === 'function' ? module[exportName] : undefined;
-  if (typeof module.default === 'function') return module.default;
-  return Object.entries(module).find(([key, value]) => typeof value === 'function' && /^[A-Z]/.test(key))?.[1];
-}
-
-(async () => {
-  try {
-    const el = document.getElementById('__octane_data');
-    const target = document.getElementById('root');
-    if (!el || !target) {
-      console.error('[octane] Unable to hydrate: missing #__octane_data or #root.');
-      return;
-    }
-    const data = JSON.parse(el.textContent || '{}'); // { entry, exportName, layout, params, url, preHydrate }
-    if (!data.entry) {
-      console.error('[octane] Unable to hydrate: no route entry in #__octane_data.');
-      return;
-    }
-
-    const pageMod = await importModule(data.entry);
-    const Component = getComponentExport(pageMod, data.exportName ?? undefined);
-    if (!Component) {
-      console.error('[octane] Unable to hydrate: no component export for', data.entry);
-      return;
-    }
-
-    const params = data.params;
-    const url = data.url;
-
-    // Run the app's pre-hydrate hook (config \`router.preHydrate\`) before the
-    // first hydration render — e.g. a client router committing its match tree
-    // so hydration adopts the same resolved tree the server rendered.
-    if (data.preHydrate) {
-      const preMod = await importModule(data.preHydrate);
-      const hook = preMod.default;
-      if (typeof hook === 'function') await hook({ url, params });
-    }
-
-    // Props mirror the server render exactly: { params, url }.
-    if (data.layout) {
-      const layoutMod = await importModule(data.layout);
-      const Layout = getComponentExport(layoutMod);
-      if (Layout) {
-        // children is a ComponentBody closing over the page props; octane's
-        // childSlot invokes a function child PROPS-FIRST as \`({}, block, extra)\`,
-        // so we ignore the empty props and render the page with its real
-        // \`{ params, url }\`, threading the scope + extra — mirroring the server
-        // createLayoutWrapper so the markers line up.
-        const children = (_props, scope, extra) => Component({ params, url }, scope, extra);
-        hydrateRoot(target, Layout, { params, url, children });
-        return;
-      }
-    }
-
-    hydrateRoot(target, Component, { params, url });
-  } catch (error) {
-    console.error('[octane] Failed to bootstrap client hydration.', error);
-  }
-})();
-`;
-}
-
-/**
- * @param {string} filename
- * @param {string} root
- * @returns {string}
- */
-export function to_vite_root_import(filename, root) {
-	return '/' + path.relative(root, filename).split(path.sep).join('/');
-}
+export {
+	RESOLVED_ADAPTER_BROWSER_STUB_ID,
+	SERVER_ONLY_ADAPTER_IDS,
+	create_adapter_browser_stub_source,
+	create_client_entry_source,
+	get_project_generated_dir,
+	normalize_module_reference,
+	to_vite_root_import,
+	write_project_generated_file,
+} from '@octanejs/app-core/codegen';

package/src/resolve-config.js

@@ -1,171 +1 @@
-// @ts-check
-/**
- * Config validation + defaults — `resolveOctaneConfig` and its validators.
- *
- * Kept in a module with NO heavy imports (no vite, no octane/compiler) because
- * it is part of the PRODUCTION server bundle's graph: the generated server
- * entry re-resolves octane.config.ts through it at boot, and the whole
- * `@octanejs/vite-plugin/production` graph is bundled into dist/server/entry.js.
- * The file-loading half (`loadOctaneConfig`, which spins up Vite) lives in
- * `load-config.js` and re-exports everything here.
- */
-
-/** @import { OctaneConfigOptions, ResolvedOctaneConfig } from '@octanejs/vite-plugin' */
-
-import { DEFAULT_OUTDIR } from './constants.js';
-
-/**
- * @param {unknown} route
- * @returns {void}
- */
-function validate_render_route(route) {
-	if (
-		!route ||
-		typeof route !== 'object' ||
-		/** @type {{ type?: unknown }} */ (route).type !== 'render'
-	) {
-		return;
-	}
-
-	const render_route = /** @type {{ entry?: unknown, layout?: unknown }} */ (route);
-	const has_entry =
-		typeof render_route.entry === 'string' ||
-		(Array.isArray(render_route.entry) &&
-			render_route.entry.length === 2 &&
-			typeof render_route.entry[0] === 'string' &&
-			typeof render_route.entry[1] === 'string');
-
-	if (!has_entry) {
-		throw new Error('[@octanejs/vite-plugin] RenderRoute requires a string/tuple `entry`.');
-	}
-
-	if (render_route.layout !== undefined && typeof render_route.layout !== 'string') {
-		throw new Error('[@octanejs/vite-plugin] RenderRoute `layout` must be a string path.');
-	}
-
-	const status = /** @type {{ status?: unknown }} */ (route).status;
-	if (status !== undefined && (typeof status !== 'number' || !Number.isInteger(status))) {
-		throw new Error('[@octanejs/vite-plugin] RenderRoute `status` must be an integer.');
-	}
-}
-
-/**
- * @param {unknown} rootBoundary
- * @returns {void}
- */
-function validate_root_boundary(rootBoundary) {
-	if (rootBoundary === undefined) {
-		return;
-	}
-	if (!rootBoundary || typeof rootBoundary !== 'object') {
-		throw new Error('[@octanejs/vite-plugin] rootBoundary must be an object when provided.');
-	}
-
-	const boundary = /** @type {{ pending?: unknown, catch?: unknown }} */ (rootBoundary);
-	if (boundary.pending !== undefined && typeof boundary.pending !== 'function') {
-		throw new Error('[@octanejs/vite-plugin] rootBoundary.pending must be a component function.');
-	}
-	if (boundary.catch !== undefined && typeof boundary.catch !== 'function') {
-		throw new Error('[@octanejs/vite-plugin] rootBoundary.catch must be a component function.');
-	}
-}
-
-/**
- * Validate a raw octane config and apply all defaults.
- *
- * After this function returns every optional field carries its default
- * value so callers never need to use `??` / `||` fallbacks.
- *
- * The function is idempotent — passing an already-resolved config
- * through it again is safe and produces the same result.
- *
- * @param {OctaneConfigOptions} raw - The user-provided config (from octane.config.ts)
- * @param {{ requireAdapter?: boolean }} [options]
- * @returns {ResolvedOctaneConfig}
- */
-export function resolveOctaneConfig(raw, options = {}) {
-	const { requireAdapter = false } = options;
-
-	// ------------------------------------------------------------------
-	// Validate
-	// ------------------------------------------------------------------
-	if (!raw) {
-		throw new Error(
-			'[@octanejs/vite-plugin] octane.config.ts must export a default config object.',
-		);
-	}
-
-	if (requireAdapter && !raw.adapter) {
-		throw new Error(
-			'[@octanejs/vite-plugin] This build requires an `adapter` in octane.config.ts. ' +
-				'Install an adapter package (e.g. @octanejs/adapter-vercel) and set the `adapter` property.',
-		);
-	}
-
-	if (raw.adapter !== undefined) {
-		if (typeof raw.adapter !== 'object' || raw.adapter === null) {
-			throw new Error(
-				'[@octanejs/vite-plugin] adapter must be an adapter object (e.g. `adapter: vercel()`).',
-			);
-		}
-		if (raw.adapter.adapt !== undefined && typeof raw.adapter.adapt !== 'function') {
-			throw new Error('[@octanejs/vite-plugin] adapter.adapt must be a function.');
-		}
-		if (raw.adapter.serve !== undefined && typeof raw.adapter.serve !== 'function') {
-			throw new Error('[@octanejs/vite-plugin] adapter.serve must be a function.');
-		}
-	}
-
-	if (raw.router?.routes !== undefined && !Array.isArray(raw.router.routes)) {
-		throw new Error('[@octanejs/vite-plugin] router.routes must be an array.');
-	}
-
-	if (raw.router?.preHydrate !== undefined) {
-		// A Vite-root module path: the client hydrate entry dynamic-imports it in
-		// the browser, so it must be root-absolute ('/src/…'), not relative or fs.
-		if (typeof raw.router.preHydrate !== 'string' || !raw.router.preHydrate.startsWith('/')) {
-			throw new Error(
-				"[@octanejs/vite-plugin] router.preHydrate must be a Vite-root module path (e.g. '/src/pre-hydrate.ts').",
-			);
-		}
-	}
-
-	for (const route of raw.router?.routes ?? []) {
-		validate_render_route(route);
-	}
-
-	validate_root_boundary(raw.rootBoundary);
-
-	if (
-		raw.server?.render !== undefined &&
-		raw.server.render !== 'streaming' &&
-		raw.server.render !== 'buffered'
-	) {
-		throw new Error("[@octanejs/vite-plugin] server.render must be 'streaming' or 'buffered'.");
-	}
-
-	// ------------------------------------------------------------------
-	// Apply defaults
-	// ------------------------------------------------------------------
-	return {
-		build: {
-			outDir: raw.build?.outDir ?? DEFAULT_OUTDIR,
-			minify: raw.build?.minify,
-			target: raw.build?.target,
-		},
-		adapter: raw.adapter,
-		router: {
-			routes: raw.router?.routes ?? [],
-			preHydrate: raw.router?.preHydrate,
-		},
-		rootBoundary: raw.rootBoundary ?? {},
-		middlewares: raw.middlewares ?? [],
-		platform: {
-			env: raw.platform?.env ?? {},
-		},
-		server: {
-			trustProxy: raw.server?.trustProxy ?? false,
-			render: raw.server?.render ?? 'streaming',
-		},
-	};
-}
+export { resolveOctaneConfig } from '@octanejs/app-core/config';

package/src/routes.js

@@ -1,133 +1 @@
-// @ts-check
-/**
- * @typedef {import('@octanejs/vite-plugin').Context} Context
- * @typedef {import('@octanejs/vite-plugin').Middleware} Middleware
- * @typedef {import('@octanejs/vite-plugin').RenderRouteOptions} RenderRouteOptions
- * @typedef {import('@octanejs/vite-plugin').ServerRouteOptions} ServerRouteOptions
- */
-
-/**
- * @typedef {string | readonly [string, string]} RenderRouteEntry
- */
-
-/**
- * @param {RenderRouteEntry | undefined} entry
- * @returns {string | undefined}
- */
-export function get_route_entry_path(entry) {
-	return typeof entry === 'string' ? entry : entry?.[1];
-}
-
-/**
- * @param {RenderRouteEntry | undefined} entry
- * @returns {string | undefined}
- */
-export function get_route_entry_export_name(entry) {
-	return typeof entry === 'string' ? undefined : entry?.[0];
-}
-
-/**
- * @param {RenderRouteEntry | undefined} entry
- * @returns {string | undefined}
- */
-export function get_route_entry_id(entry) {
-	const path = get_route_entry_path(entry);
-	const export_name = get_route_entry_export_name(entry);
-	return path && export_name ? `${path}#${export_name}` : path;
-}
-
-/**
- * @param {Record<string, unknown>} module
- * @param {string | undefined} export_name
- * @returns {Function | null}
- */
-export function get_component_export(module, export_name) {
-	// When an explicit export name is given, require an exact match. Do NOT fall
-	// back to default/first-PascalCase — a typo'd route tuple should fail loudly
-	// rather than silently render the wrong component.
-	if (export_name) {
-		return typeof module[export_name] === 'function' ? module[export_name] : null;
-	}
-	if (typeof module.default === 'function') {
-		return module.default;
-	}
-	for (const [key, value] of Object.entries(module)) {
-		if (typeof value === 'function' && /^[A-Z]/.test(key)) {
-			return value;
-		}
-	}
-	return null;
-}
-
-/**
- * Route for rendering octane components with SSR
- */
-export class RenderRoute {
-	/** @type {'render'} */
-	type = 'render';
-
-	/** @type {string} */
-	path;
-
-	// Non-optional: the constructor throws without one (matches types/index.d.ts).
-	/** @type {RenderRouteEntry} */
-	entry;
-
-	/** @type {string | undefined} */
-	layout;
-
-	/** @type {Middleware[]} */
-	before;
-
-	/** @type {number | undefined} */
-	status;
-
-	/**
-	 * @param {RenderRouteOptions} options
-	 */
-	constructor(options) {
-		if (!options.entry) {
-			throw new Error('RenderRoute requires an `entry`.');
-		}
-
-		this.path = options.path;
-		this.entry = options.entry;
-		this.layout = options.layout;
-		this.before = options.before ?? [];
-		this.status = options.status;
-	}
-}
-
-/**
- * Route for API endpoints (returns Response directly)
- */
-export class ServerRoute {
-	/** @type {'server'} */
-	type = 'server';
-
-	/** @type {string} */
-	path;
-
-	/** @type {string[]} */
-	methods;
-
-	/** @type {(context: Context) => Response | Promise<Response>} */
-	handler;
-
-	/** @type {Middleware[]} */
-	before;
-
-	/** @type {Middleware[]} */
-	after;
-
-	/**
-	 * @param {ServerRouteOptions} options
-	 */
-	constructor(options) {
-		this.path = options.path;
-		this.methods = options.methods ?? ['GET'];
-		this.handler = options.handler;
-		this.before = options.before ?? [];
-		this.after = options.after ?? [];
-	}
-}
+export * from '@octanejs/app-core/routes';

package/src/server/component-wrappers.js

@@ -1,56 +1,5 @@
-// @ts-check
-/**
- * Server component composition for the octane renderer.
- *
- * octane's server ABI is PROPS-FIRST (matching the client): a component body is
- * `(props, scope, extra) => string`. `render(Component, props)` invokes the ROOT
- * directly as `Component(props, rootScope, undefined)` and does NOT wrap it in
- * block markers — and `hydrateRoot()` adopts the container's FIRST CHILD as the
- * root's own node. So the wrapper must call the top-level component DIRECTLY
- * (wrapping it in `ssrComponent` would add an extra `<!--[-->…<!--]-->` layer that
- * `clone()` then mis-adopts on hydrate).
- *
- * Only the layout's `{children}` is a nested hole: the compiled layout emits
- * `ssrChild(props.children, scope)`, and `ssrChild` invokes a FUNCTION child as
- * `children({}, scope, undefined)` wrapped in one `<!--[-->…<!--]-->` range. So
- * `children` is a ComponentBody that calls the page directly, and any page data
- * (params) rides its CLOSURE — `ssrChild` supplies only `{}`. The client
- * `childSlot` applies the identical rule (bare function = ComponentBody, `{}`
- * props, one marker range), so server markers and client adoption line up.
- *
- * @typedef {(props?: any, scope?: any, extra?: any) => string} ServerComponent
- */
-
-/**
- * Wrap a page component, baking in its route props.
- *
- * @param {ServerComponent} Page
- * @param {Record<string, unknown>} pageProps
- * @returns {ServerComponent}
- */
-export function createPropsWrapper(Page, pageProps) {
-	return function Root(_props, scope) {
-		return Page(pageProps, scope, undefined);
-	};
-}
-
-/**
- * Compose a layout with a page: the layout's `{children}` renders the page.
- *
- * @param {ServerComponent} Layout
- * @param {ServerComponent} Page
- * @param {Record<string, unknown>} pageProps
- * @returns {ServerComponent}
- */
-export function createLayoutWrapper(Layout, Page, pageProps) {
-	return function Root(_props, scope) {
-		// `children` is a ComponentBody closing over pageProps; the layout's
-		// `{children}` hole runs it via ssrChild (which supplies `{}` props and
-		// wraps the output in one block range), so the page still gets its real
-		// route props through the closure. PROPS-FIRST: childSlot/ssrChild call it
-		// as `({}, scope, extra)`, so the page's real props are passed explicitly.
-		const children = (/** @type {any} */ _cprops, /** @type {any} */ cscope) =>
-			Page(pageProps, cscope, undefined);
-		return Layout({ ...pageProps, children }, scope, undefined);
-	};
-}
+export {
+	createLayoutWrapper,
+	createPropsWrapper,
+	createRootBoundaryWrapper,
+} from '@octanejs/app-core/production';

package/src/server/html-stream.js

@@ -0,0 +1 @@
+export { composeHtmlStream } from '@octanejs/app-core/html';

package/src/server/html-template.js

@@ -0,0 +1,9 @@
+export {
+	HYDRATION_NONCE_PLACEHOLDER,
+	applyHydrationNonce,
+	getContextNonce,
+	injectHydrationEntry,
+	nonceAttribute,
+	splitSsrTemplate,
+	validateSsrTemplate,
+} from '@octanejs/app-core/html';