@octanejs/vite-plugin 0.1.5 → 0.1.9

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';

package/src/server/middleware.js

@@ -1,127 +1 @@
-// @ts-check
-/**
- * @typedef {import('@octanejs/vite-plugin').Context} Context
- * @typedef {import('@octanejs/vite-plugin').Middleware} Middleware
- * @typedef {import('@octanejs/vite-plugin').NextFunction} NextFunction
- */
-
-/**
- * Compose multiple middlewares into a single middleware
- * Follows Koa-style execution: request flows down, response flows back up
- *
- * @param {Middleware[]} middlewares
- * @returns {(context: Context, finalHandler: () => Promise<Response>) => Promise<Response>}
- */
-export function compose(middlewares) {
-	return function composed(context, finalHandler) {
-		let index = -1;
-
-		/**
-		 * @param {number} i
-		 * @returns {Promise<Response>}
-		 */
-		function dispatch(i) {
-			if (i <= index) {
-				return Promise.reject(new Error('next() called multiple times'));
-			}
-			index = i;
-
-			/** @type {Middleware | (() => Promise<Response>) | undefined} */
-			let fn;
-
-			if (i < middlewares.length) {
-				fn = middlewares[i];
-			} else if (i === middlewares.length) {
-				fn = finalHandler;
-			}
-
-			if (!fn) {
-				return Promise.reject(new Error('No handler provided'));
-			}
-
-			try {
-				// For the final handler, we don't pass next
-				if (i === middlewares.length) {
-					return Promise.resolve(/** @type {() => Promise<Response>} */ (fn)());
-				}
-				// For middlewares, pass context and next
-				return Promise.resolve(/** @type {Middleware} */ (fn)(context, () => dispatch(i + 1)));
-			} catch (err) {
-				return Promise.reject(err);
-			}
-		}
-
-		return dispatch(0);
-	};
-}
-
-/**
- * Create a context object for the request
- * @param {Request} request
- * @param {Record<string, string>} params
- * @returns {Context}
- */
-export function createContext(request, params) {
-	return {
-		request,
-		params,
-		url: new URL(request.url),
-		state: new Map(),
-	};
-}
-
-/**
- * Run middlewares with a final handler
- * Combines global middlewares, route-level before/after, and the handler
- *
- * @param {Context} context
- * @param {Middleware[]} globalMiddlewares
- * @param {Middleware[]} beforeMiddlewares
- * @param {() => Promise<Response>} handler
- * @param {Middleware[]} afterMiddlewares
- * @returns {Promise<Response>}
- */
-export async function runMiddlewareChain(
-	context,
-	globalMiddlewares,
-	beforeMiddlewares,
-	handler,
-	afterMiddlewares = [],
-) {
-	// Combine global + before middlewares
-	const allMiddlewares = [...globalMiddlewares, ...beforeMiddlewares];
-
-	// If there are after middlewares, wrap the handler to run them
-	const wrappedHandler =
-		afterMiddlewares.length > 0
-			? async () => {
-					const response = await handler();
-					// After middlewares can inspect/modify the response
-					// but have limited ability to change it in our model
-					// We run them for side-effects (logging, etc.)
-					return runAfterMiddlewares(context, afterMiddlewares, response);
-				}
-			: handler;
-
-	const composed = compose(allMiddlewares);
-	return composed(context, wrappedHandler);
-}
-
-/**
- * Run after middlewares with the response
- * After middlewares run in order and can intercept/modify the response
- *
- * @param {Context} context
- * @param {Middleware[]} middlewares
- * @param {Response} response
- * @returns {Promise<Response>}
- */
-async function runAfterMiddlewares(context, middlewares, response) {
-	let currentResponse = response;
-
-	for (const middleware of middlewares) {
-		currentResponse = await middleware(context, async () => currentResponse);
-	}
-
-	return currentResponse;
-}
+export * from '@octanejs/app-core/middleware';

package/src/server/node-http.js

@@ -1,188 +1 @@
-// @ts-check
-/**
- * Node HTTP glue — shared by the dev middleware (src/index.js), the generated
- * production server entry (its `nodeHandler` export for serverless wrappers),
- * and the built-in production server (`createNodeServer`, the no-adapter
- * default boot). Exported as '@octanejs/vite-plugin/node'.
- *
- * This module may import node builtins (unlike server/production.js, which is
- * platform-agnostic) — it IS the Node platform layer.
- */
-
-import http from 'node:http';
-import fs from 'node:fs';
-import path from 'node:path';
-import { Readable } from 'node:stream';
-
-/**
- * Convert a Node.js IncomingMessage to a Web Request.
- * @param {import('node:http').IncomingMessage} nodeRequest
- * @returns {Request}
- */
-export function nodeRequestToWebRequest(nodeRequest) {
-	const host = nodeRequest.headers.host || 'localhost';
-	const url = new URL(nodeRequest.url || '/', `http://${host}`);
-
-	const headers = new Headers();
-	for (const [key, value] of Object.entries(nodeRequest.headers)) {
-		if (value == null) continue;
-		if (Array.isArray(value)) {
-			for (const v of value) headers.append(key, v);
-		} else {
-			headers.set(key, value);
-		}
-	}
-
-	const method = (nodeRequest.method || 'GET').toUpperCase();
-	/** @type {RequestInit & { duplex?: 'half' }} */
-	const init = { method, headers };
-	if (method !== 'GET' && method !== 'HEAD') {
-		// node:stream/web's ReadableStream and the DOM lib's are structurally the
-		// same at runtime; the lib types disagree on BYOB details.
-		init.body = /** @type {ReadableStream} */ (
-			/** @type {unknown} */ (Readable.toWeb(nodeRequest))
-		);
-		init.duplex = 'half';
-	}
-	return new Request(url, init);
-}
-
-/**
- * Pipe a Web Response to a Node.js ServerResponse. Streams chunk-by-chunk so a
- * streaming SSR body flushes as it renders (no buffering).
- *
- * @param {import('node:http').ServerResponse} nodeResponse
- * @param {Response} webResponse
- */
-export async function sendWebResponse(nodeResponse, webResponse) {
-	nodeResponse.statusCode = webResponse.status;
-	if (webResponse.statusText) nodeResponse.statusMessage = webResponse.statusText;
-	webResponse.headers.forEach((value, key) => {
-		nodeResponse.setHeader(key, value);
-	});
-	if (webResponse.body) {
-		const reader = webResponse.body.getReader();
-		try {
-			while (true) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				nodeResponse.write(value);
-			}
-		} finally {
-			reader.releaseLock();
-		}
-	}
-	nodeResponse.end();
-}
-
-// Static-file MIME map (the common web set; anything else falls back to
-// octet-stream, which is correct for downloads).
-/** @type {Record<string, string>} */
-const MIME_TYPES = {
-	'.html': 'text/html; charset=utf-8',
-	'.css': 'text/css; charset=utf-8',
-	'.js': 'text/javascript; charset=utf-8',
-	'.mjs': 'text/javascript; charset=utf-8',
-	'.json': 'application/json; charset=utf-8',
-	'.png': 'image/png',
-	'.jpg': 'image/jpeg',
-	'.jpeg': 'image/jpeg',
-	'.gif': 'image/gif',
-	'.svg': 'image/svg+xml',
-	'.ico': 'image/x-icon',
-	'.woff': 'font/woff',
-	'.woff2': 'font/woff2',
-	'.ttf': 'font/ttf',
-	'.otf': 'font/otf',
-	'.webp': 'image/webp',
-	'.avif': 'image/avif',
-	'.mp4': 'video/mp4',
-	'.webm': 'video/webm',
-	'.txt': 'text/plain; charset=utf-8',
-	'.xml': 'application/xml',
-	'.wasm': 'application/wasm',
-	'.map': 'application/json',
-};
-
-/**
- * Serve a static file from `staticDir` if the request path maps to one.
- * Hash-named build assets (everything under /assets/) get immutable caching;
- * other files (favicon, robots.txt, …) revalidate.
- *
- * @param {import('node:http').IncomingMessage} req
- * @param {import('node:http').ServerResponse} res
- * @param {string} staticDir
- * @returns {boolean} true when the request was handled as a static file
- */
-export function serveStaticFile(req, res, staticDir) {
-	const method = (req.method || 'GET').toUpperCase();
-	if (method !== 'GET' && method !== 'HEAD') return false;
-
-	const pathname = decodeURIComponent(new URL(req.url || '/', 'http://localhost').pathname);
-	// Resolve inside staticDir only — a `..` escape must not leave the client dir.
-	const filePath = path.normalize(path.join(staticDir, pathname));
-	if (!filePath.startsWith(path.normalize(staticDir + path.sep))) return false;
-
-	/** @type {fs.Stats} */
-	let stat;
-	try {
-		stat = fs.statSync(filePath);
-	} catch {
-		return false;
-	}
-	if (!stat.isFile()) return false;
-
-	const ext = path.extname(filePath).toLowerCase();
-	res.statusCode = 200;
-	res.setHeader('Content-Type', MIME_TYPES[ext] || 'application/octet-stream');
-	res.setHeader('Content-Length', stat.size);
-	res.setHeader(
-		'Cache-Control',
-		pathname.startsWith('/assets/')
-			? 'public, max-age=31536000, immutable'
-			: 'public, max-age=0, must-revalidate',
-	);
-	if (method === 'HEAD') {
-		res.end();
-	} else {
-		fs.createReadStream(filePath).pipe(res);
-	}
-	return true;
-}
-
-/**
- * Minimal production HTTP server: static files from `staticDir` first (built
- * client assets), then the fetch-style SSR handler. This is the DEFAULT boot
- * when octane.config.ts has no adapter — an adapter's `serve()` replaces it.
- *
- * @param {(request: Request) => Response | Promise<Response>} handler
- * @param {{ staticDir?: string }} [options]
- * @returns {{ listen: (port?: number) => import('node:http').Server, close: () => void }}
- */
-export function createNodeServer(handler, options = {}) {
-	const staticDir = options.staticDir;
-
-	const server = http.createServer((req, res) => {
-		(async () => {
-			if (staticDir && serveStaticFile(req, res, staticDir)) return;
-			const response = await handler(nodeRequestToWebRequest(req));
-			await sendWebResponse(res, response);
-		})().catch((error) => {
-			console.error('[@octanejs/vite-plugin] Request error:', error);
-			if (!res.headersSent) {
-				res.statusCode = 500;
-				res.setHeader('Content-Type', 'text/plain; charset=utf-8');
-			}
-			res.end('Internal Server Error');
-		});
-	});
-
-	return {
-		listen(port = 3000) {
-			return server.listen(port);
-		},
-		close() {
-			server.close();
-		},
-	};
-}
+export * from '@octanejs/app-core/node';