@octanejs/tanstack-start 0.1.0

package/src/internal/start-plugin-core/post-build.js

@@ -0,0 +1,40 @@
+import { buildSitemap } from './build-sitemap.js';
+import { HEADERS } from '@tanstack/start-server-core';
+//#region src/post-build.ts
+async function postBuild({ startConfig, adapter }) {
+	if (startConfig.prerender?.enabled !== false)
+		startConfig.prerender = {
+			...startConfig.prerender,
+			enabled:
+				startConfig.prerender?.enabled ??
+				startConfig.pages.some((d) => (typeof d === 'string' ? false : !!d.prerender?.enabled)),
+		};
+	if (startConfig.spa?.enabled) {
+		startConfig.prerender = {
+			...startConfig.prerender,
+			enabled: true,
+		};
+		const maskUrl = new URL(startConfig.spa.maskPath, 'http://localhost');
+		if (maskUrl.origin !== 'http://localhost')
+			throw new Error('spa.maskPath must be a path (no protocol/host)');
+		startConfig.pages.push({
+			path: maskUrl.toString().replace('http://localhost', ''),
+			prerender: {
+				...startConfig.spa.prerender,
+				headers: {
+					...startConfig.spa.prerender.headers,
+					[HEADERS.TSS_SHELL]: 'true',
+				},
+			},
+			sitemap: { exclude: true },
+		});
+	}
+	if (startConfig.prerender.enabled) await adapter.prerender(startConfig);
+	if (startConfig.sitemap?.enabled)
+		buildSitemap({
+			startConfig,
+			publicDir: adapter.getClientOutputDirectory(),
+		});
+}
+//#endregion
+export { postBuild };

package/src/internal/start-plugin-core/prerender.d.ts

@@ -0,0 +1,17 @@
+import { Page, TanStackStartOutputConfig } from './schema.js';
+export interface PrerenderHandler {
+	getClientOutputDirectory: () => string;
+	request: (path: string, options?: RequestInit) => Promise<Response>;
+	close?: () => Promise<void>;
+}
+export declare function prerender({
+	startConfig,
+	handler,
+}: {
+	startConfig: TanStackStartOutputConfig;
+	handler: PrerenderHandler;
+}): Promise<void>;
+export declare function validateAndNormalizePrerenderPages(
+	pages: Array<Page>,
+	routerBaseUrl: URL,
+): Array<Page>;

package/src/internal/start-plugin-core/prerender.js

@@ -0,0 +1,172 @@
+import { createLogger } from './utils.js';
+import { Queue } from './queue.js';
+import path from 'pathe';
+import { promises } from 'node:fs';
+import { joinURL, withBase, withTrailingSlash, withoutBase } from 'ufo';
+import os from 'node:os';
+//#region src/prerender.ts
+var DEFAULT_RETRY_DELAY = 500;
+async function prerender({ startConfig, handler }) {
+	const logger = createLogger('prerender');
+	logger.info('Prerendering pages...');
+	if (startConfig.prerender?.enabled) {
+		let pages = startConfig.pages.length ? startConfig.pages : [{ path: '/' }];
+		if (startConfig.prerender.autoStaticPathsDiscovery ?? true) {
+			const pagesMap = new Map(pages.map((item) => [item.path, item]));
+			const discoveredPages = globalThis.TSS_PRERENDABLE_PATHS || [];
+			for (const page of discoveredPages)
+				if (!pagesMap.has(page.path)) pagesMap.set(page.path, page);
+			pages = Array.from(pagesMap.values());
+		}
+		startConfig.pages = pages;
+	}
+	const routerBasePath = joinURL('/', startConfig.router.basepath ?? '');
+	const routerBaseUrl = new URL(routerBasePath, 'http://localhost');
+	startConfig.pages = validateAndNormalizePrerenderPages(startConfig.pages, routerBaseUrl);
+	try {
+		const pages = await prerenderPages({ outputDir: handler.getClientOutputDirectory() });
+		logger.info(`Prerendered ${pages.length} pages:`);
+		pages.forEach((page) => {
+			logger.info(`- ${page}`);
+		});
+	} catch (error) {
+		logger.error(error);
+		throw error;
+	} finally {
+		await handler.close?.();
+	}
+	function extractLinks(html) {
+		const linkRegex = /<a[^>]+href=["']([^"']+)["'][^>]*>/g;
+		const links = [];
+		let match;
+		while ((match = linkRegex.exec(html)) !== null) {
+			const href = match[1];
+			if (href && (href.startsWith('/') || href.startsWith('./'))) links.push(href);
+		}
+		return links;
+	}
+	async function prerenderPages({ outputDir }) {
+		const seen = /* @__PURE__ */ new Set();
+		const prerendered = /* @__PURE__ */ new Set();
+		const retriesByPath = /* @__PURE__ */ new Map();
+		const concurrency = startConfig.prerender?.concurrency ?? os.cpus().length;
+		logger.info(`Concurrency: ${concurrency}`);
+		const queue = new Queue({ concurrency });
+		const routerBasePath = joinURL('/', startConfig.router.basepath ?? '');
+		const routerBaseUrl = new URL(routerBasePath, 'http://localhost');
+		startConfig.pages = validateAndNormalizePrerenderPages(startConfig.pages, routerBaseUrl);
+		startConfig.pages.forEach((page) => addCrawlPageTask(page));
+		if (queue.isSettled()) {
+			logger.info('No pages matched prerender filter; skipping.');
+			return Array.from(prerendered);
+		}
+		await queue.start();
+		return Array.from(prerendered);
+		function addCrawlPageTask(page) {
+			if (seen.has(page.path)) return;
+			seen.add(page.path);
+			if (page.fromCrawl) startConfig.pages.push(page);
+			if (!(page.prerender?.enabled ?? true)) return;
+			if (startConfig.prerender?.filter && !startConfig.prerender.filter(page)) return;
+			const prerenderOptions = {
+				...startConfig.prerender,
+				...page.prerender,
+			};
+			queue.add(async () => {
+				logger.info(`Crawling: ${page.path}`);
+				const retries = retriesByPath.get(page.path) || 0;
+				try {
+					const res = await requestWithRedirects(
+						withTrailingSlash(withBase(page.path, routerBasePath)),
+						{ headers: { ...(prerenderOptions.headers ?? {}) } },
+						prerenderOptions.maxRedirects,
+					);
+					if (!res.ok) {
+						if (isRedirectResponse(res)) logger.warn(`Max redirects reached for ${page.path}`);
+						throw new Error(`Failed to fetch ${page.path}: ${res.statusText}`, { cause: res });
+					}
+					const cleanPagePath = (prerenderOptions.outputPath || page.path).split(/[?#]/)[0];
+					const contentType = res.headers.get('content-type') || '';
+					const isImplicitHTML = !cleanPagePath.endsWith('.html') && contentType.includes('html');
+					const routeWithIndex = cleanPagePath.endsWith('/')
+						? cleanPagePath + 'index'
+						: cleanPagePath;
+					const isSpaShell = startConfig.spa?.prerender.outputPath === cleanPagePath;
+					let htmlPath;
+					if (isSpaShell) htmlPath = cleanPagePath + '.html';
+					else if (cleanPagePath.endsWith('/') || (prerenderOptions.autoSubfolderIndex ?? true))
+						htmlPath = joinURL(cleanPagePath, 'index.html');
+					else htmlPath = cleanPagePath + '.html';
+					const filename = withoutBase(isImplicitHTML ? htmlPath : routeWithIndex, routerBasePath);
+					const html = await res.text();
+					const filepath = path.join(outputDir, filename);
+					await promises.mkdir(path.dirname(filepath), { recursive: true });
+					await promises.writeFile(filepath, html);
+					prerendered.add(page.path);
+					const newPage = await prerenderOptions.onSuccess?.({
+						page,
+						html,
+					});
+					if (newPage) Object.assign(page, newPage);
+					if (prerenderOptions.crawlLinks ?? true) {
+						const links = extractLinks(html);
+						for (const link of links)
+							addCrawlPageTask({
+								path: link,
+								fromCrawl: true,
+							});
+					}
+				} catch (error) {
+					if (retries < (prerenderOptions.retryCount ?? 0)) {
+						const retryDelay = normalizeRetryDelay(prerenderOptions.retryDelay);
+						logger.warn(`Encountered error, retrying: ${page.path} in ${retryDelay}ms`);
+						await new Promise((resolve) => setTimeout(resolve, retryDelay));
+						retriesByPath.set(page.path, retries + 1);
+						addCrawlPageTask(page);
+					} else if (prerenderOptions.failOnError ?? true) throw error;
+				}
+			});
+		}
+	}
+	function normalizeRetryDelay(value) {
+		const retryDelay = Number(value);
+		if (!Number.isFinite(retryDelay) || retryDelay < 0) return DEFAULT_RETRY_DELAY;
+		return Math.trunc(retryDelay);
+	}
+	async function requestWithRedirects(path, options, maxRedirects = 5) {
+		const response = await handler.request(path, options);
+		if (isRedirectResponse(response) && maxRedirects > 0) {
+			const location = response.headers.get('location');
+			if (location.startsWith('http://localhost') || location.startsWith('/'))
+				return requestWithRedirects(
+					location.replace('http://localhost', ''),
+					options,
+					maxRedirects - 1,
+				);
+			logger.warn(`Skipping redirect to external location: ${location}`);
+		}
+		return response;
+	}
+}
+function isRedirectResponse(res) {
+	return res.status >= 300 && res.status < 400 && res.headers.get('location');
+}
+function validateAndNormalizePrerenderPages(pages, routerBaseUrl) {
+	return pages.map((page) => {
+		let url;
+		try {
+			url = new URL(page.path, routerBaseUrl);
+		} catch (err) {
+			throw new Error(`prerender page path must be relative: ${page.path}`, { cause: err });
+		}
+		if (url.origin !== 'http://localhost')
+			throw new Error(`prerender page path must be relative: ${page.path}`);
+		const decodedPathname = decodeURIComponent(url.pathname);
+		return {
+			...page,
+			path: decodedPathname + url.search + url.hash,
+		};
+	});
+}
+//#endregion
+export { prerender };

package/src/internal/start-plugin-core/queue.d.ts

@@ -0,0 +1,37 @@
+interface PoolConfig {
+	concurrency?: number;
+	started?: boolean;
+	tasks?: Array<() => Promise<any>>;
+}
+export declare class Queue<T> {
+	private onSettles;
+	private onErrors;
+	private onSuccesses;
+	private running;
+	private active;
+	private pending;
+	private currentConcurrency;
+	constructor(config?: PoolConfig);
+	private tick;
+	add(
+		fn: () => Promise<T> | T,
+		{
+			priority,
+		}?: {
+			priority?: boolean;
+		},
+	): Promise<any>;
+	throttle(n: number): void;
+	onSettled(cb: () => void): () => void;
+	onError(cb: (error: any, task: () => Promise<any>) => void): () => void;
+	onSuccess(cb: (result: any, task: () => Promise<any>) => void): () => void;
+	stop(): void;
+	start(): Promise<void>;
+	clear(): void;
+	getActive(): (() => Promise<any>)[];
+	getPending(): (() => Promise<any>)[];
+	getAll(): (() => Promise<any>)[];
+	isRunning(): boolean;
+	isSettled(): boolean;
+}
+export {};

package/src/internal/start-plugin-core/queue.js

@@ -0,0 +1,118 @@
+//#region src/queue.ts
+var defaultConfig = {
+	concurrency: 5,
+	started: false,
+	tasks: [],
+};
+var Queue = class {
+	onSettles = [];
+	onErrors = [];
+	onSuccesses = [];
+	running;
+	active = [];
+	pending;
+	currentConcurrency;
+	constructor(config = defaultConfig) {
+		const { concurrency, started, tasks } = {
+			...defaultConfig,
+			...config,
+		};
+		this.running = started;
+		this.pending = tasks;
+		this.currentConcurrency = concurrency;
+	}
+	tick() {
+		if (!this.running) return;
+		while (this.active.length < this.currentConcurrency && this.pending.length) {
+			const nextFn = this.pending.shift();
+			if (!nextFn) throw new Error('Found task that is not a function');
+			this.active.push(nextFn);
+			(async () => {
+				let success = false;
+				let res;
+				let error;
+				try {
+					res = await nextFn();
+					success = true;
+				} catch (e) {
+					error = e;
+				}
+				this.active = this.active.filter((d) => d !== nextFn);
+				if (success) this.onSuccesses.forEach((d) => d(res, nextFn));
+				else this.onErrors.forEach((d) => d(error, nextFn));
+				this.onSettles.forEach((d) => d(res, error));
+				this.tick();
+			})();
+		}
+	}
+	add(fn, { priority } = {}) {
+		return new Promise((resolve, reject) => {
+			const task = () =>
+				Promise.resolve(fn())
+					.then((res) => {
+						resolve(res);
+						return res;
+					})
+					.catch((err) => {
+						reject(err);
+						throw err;
+					});
+			if (priority) this.pending.unshift(task);
+			else this.pending.push(task);
+			this.tick();
+		});
+	}
+	throttle(n) {
+		this.currentConcurrency = n;
+	}
+	onSettled(cb) {
+		this.onSettles.push(cb);
+		return () => {
+			this.onSettles = this.onSettles.filter((d) => d !== cb);
+		};
+	}
+	onError(cb) {
+		this.onErrors.push(cb);
+		return () => {
+			this.onErrors = this.onErrors.filter((d) => d !== cb);
+		};
+	}
+	onSuccess(cb) {
+		this.onSuccesses.push(cb);
+		return () => {
+			this.onSuccesses = this.onSuccesses.filter((d) => d !== cb);
+		};
+	}
+	stop() {
+		this.running = false;
+	}
+	start() {
+		this.running = true;
+		this.tick();
+		return new Promise((resolve) => {
+			this.onSettled(() => {
+				if (this.isSettled()) resolve();
+			});
+		});
+	}
+	clear() {
+		this.pending = [];
+	}
+	getActive() {
+		return this.active;
+	}
+	getPending() {
+		return this.pending;
+	}
+	getAll() {
+		return [...this.active, ...this.pending];
+	}
+	isRunning() {
+		return this.running;
+	}
+	isSettled() {
+		return !this.active.length && !this.pending.length;
+	}
+};
+//#endregion
+export { Queue };

package/src/internal/start-plugin-core/resolve-entries.d.ts

@@ -0,0 +1,10 @@
+export declare function resolveEntry<
+	TRequired extends boolean,
+	TReturn = TRequired extends true ? string : string | undefined,
+>(opts: {
+	type: string;
+	configuredEntry?: string;
+	defaultEntry: string;
+	resolvedSrcDirectory: string;
+	required: TRequired;
+}): TReturn;

package/src/internal/start-plugin-core/resolve-entries.js

@@ -0,0 +1,32 @@
+import { resolveModulePath } from 'exsolve';
+//#region src/resolve-entries.ts
+function resolveModule(opts) {
+	let baseName = opts.baseName;
+	if (!baseName.startsWith('./')) baseName = `./${baseName}`;
+	return resolveModulePath(baseName, {
+		from: opts.from,
+		extensions: ['.ts', '.js', '.mts', '.mjs', '.tsx', '.jsx', '.tsrx'],
+		try: true,
+	});
+}
+function resolveEntry(opts) {
+	let resolveOptions;
+	if (!opts.configuredEntry)
+		resolveOptions = {
+			baseName: opts.defaultEntry,
+			from: opts.resolvedSrcDirectory,
+		};
+	else
+		resolveOptions = {
+			baseName: opts.configuredEntry,
+			from: opts.resolvedSrcDirectory,
+		};
+	const resolvedEntry = resolveModule(resolveOptions);
+	if (opts.required && !resolvedEntry)
+		throw new Error(
+			`Could not resolve entry for ${opts.type}: ${resolveOptions.baseName} in ${resolveOptions.from}`,
+		);
+	return resolvedEntry;
+}
+//#endregion
+export { resolveEntry };