@octanejs/tanstack-start 0.1.0

package/src/internal/router-plugin/core/hmr/vite-adapter.js

@@ -0,0 +1,73 @@
+import { getHandleRouteUpdateCode } from './handle-route-update.js';
+import * as template from '@babel/template';
+//#region src/core/hmr/vite-adapter.ts
+/**
+ * Emits HMR accept code for Vite / native ESM HMR: `import.meta.hot.accept`
+ * with a callback that receives the freshly re-imported module.
+ *
+ * Framework-specific component runtimes still own component body patching.
+ * The route signature only suppresses a redundant data invalidation when an
+ * Octane update changed extracted component code but not the route definition.
+ */
+function createViteHmrStatement(stableRouteOptionKeys, opts) {
+	const handleRouteUpdateCode = getHandleRouteUpdateCode(stableRouteOptionKeys);
+	const routeIdFallback =
+		typeof opts.routeId === 'string' ? JSON.stringify(opts.routeId) : 'Route.id';
+	const routeSignature =
+		typeof opts.routeSignature === 'string' ? JSON.stringify(opts.routeSignature) : 'undefined';
+	const shouldInvalidateCurrentRoute =
+		opts.targetFramework === 'octane'
+			? `typeof routeSignature !== 'string' || previousRouteSignature !== routeSignature`
+			: 'true';
+	const shouldInvalidateNextRoute =
+		opts.targetFramework === 'octane'
+			? `typeof routeSignature !== 'string' || nextRouteSignature !== routeSignature`
+			: 'true';
+	return [
+		template.statement(
+			`
+if (import.meta.hot) {
+  const hot = import.meta.hot
+  const hotData = hot.data ??= {}
+  const handleRouteUpdate = ${handleRouteUpdateCode}
+  const routeSignatureKey = Symbol.for('tanstack.router.hmr.route-signature')
+  const routeSignature = ${routeSignature}
+  const previousRouteSignature = hotData['tsr-route-signature']
+  const shouldInvalidateCurrentRoute = ${shouldInvalidateCurrentRoute}
+  Route[routeSignatureKey] = routeSignature
+  hotData['tsr-route-signature'] = routeSignature
+  const initialRouteId = ${routeIdFallback} ?? hotData['tsr-route-id']
+  if (initialRouteId) {
+    hotData['tsr-route-id'] = initialRouteId
+  }
+  const existingRoute =
+    typeof window !== 'undefined' && initialRouteId
+      ? window.__TSR_ROUTER__?.routesById?.[initialRouteId]
+      : undefined
+  if (initialRouteId && existingRoute && existingRoute !== Route) {
+    handleRouteUpdate(initialRouteId, Route, shouldInvalidateCurrentRoute)
+    hotData['tsr-route-update-handled'] = Route
+  }
+  import.meta.hot.accept((newModule) => {
+    if (Route && newModule && newModule.Route) {
+      const routeId = hotData['tsr-route-id'] ?? ${routeIdFallback}
+      if (routeId) {
+        hotData['tsr-route-id'] = routeId
+      }
+      if (hotData['tsr-route-update-handled'] === newModule.Route) {
+        delete hotData['tsr-route-update-handled']
+        return
+      }
+      const nextRouteSignature = newModule.Route[routeSignatureKey]
+      const shouldInvalidateNextRoute = ${shouldInvalidateNextRoute}
+      handleRouteUpdate(routeId, newModule.Route, shouldInvalidateNextRoute)
+    }
+    })
+}
+`,
+			{ syntacticPlaceholders: true },
+		)(),
+	];
+}
+//#endregion
+export { createViteHmrStatement };

package/src/internal/router-plugin/core/hmr/webpack-adapter.d.ts

@@ -0,0 +1,22 @@
+import { Config } from '../config.js';
+import type * as t from '@babel/types';
+/**
+ * Emits HMR accept code for bundlers with webpack-compatible `module.hot`
+ * semantics (classic webpack via `import.meta.webpackHot`, and Rspack).
+ *
+ * Unlike Vite's `hot.accept((newModule) => {...})` — where the callback receives
+ * the freshly re-imported module — webpack re-executes the module factory on
+ * accept, so our HMR logic must live at module top level and read the previous
+ * `routeId` out of `hot.data`. `hot.dispose` stashes it for the next run, and
+ * `hot.accept()` (no callback) enrolls us as a self-accepting boundary.
+ *
+ * Returns an array of statements that patches route definitions during HMR.
+ */
+export declare function createWebpackHmrStatement(
+	stableRouteOptionKeys: Array<string>,
+	opts: {
+		targetFramework: Config['target'];
+		routeId?: string;
+		routeSignature?: string;
+	},
+): Array<t.Statement>;

package/src/internal/router-plugin/core/hmr/webpack-adapter.js

@@ -0,0 +1,78 @@
+import { getHandleRouteUpdateCode } from './handle-route-update.js';
+import * as template from '@babel/template';
+//#region src/core/hmr/webpack-adapter.ts
+/**
+ * Emits HMR accept code for bundlers with webpack-compatible `module.hot`
+ * semantics (classic webpack via `import.meta.webpackHot`, and Rspack).
+ *
+ * Unlike Vite's `hot.accept((newModule) => {...})` — where the callback receives
+ * the freshly re-imported module — webpack re-executes the module factory on
+ * accept, so our HMR logic must live at module top level and read the previous
+ * `routeId` out of `hot.data`. `hot.dispose` stashes it for the next run, and
+ * `hot.accept()` (no callback) enrolls us as a self-accepting boundary.
+ *
+ * Returns an array of statements that patches route definitions during HMR.
+ */
+function createWebpackHmrStatement(stableRouteOptionKeys, opts) {
+	const handleRouteUpdateCode = getHandleRouteUpdateCode(stableRouteOptionKeys);
+	const staticRouteIdLiteral =
+		typeof opts.routeId === 'string' ? JSON.stringify(opts.routeId) : 'undefined';
+	const routeSignature =
+		typeof opts.routeSignature === 'string' ? JSON.stringify(opts.routeSignature) : 'undefined';
+	const shouldInvalidateRoute =
+		opts.targetFramework === 'octane'
+			? `typeof routeSignature !== 'string' || previousRouteSignature !== routeSignature`
+			: 'true';
+	const reactRefreshCall =
+		opts.targetFramework === 'react'
+			? `
+    try {
+      const tsrReactRefreshUtils =
+        typeof __react_refresh_utils__ !== 'undefined'
+          ? __react_refresh_utils__
+          : undefined
+      const tsrEnqueueUpdate =
+        tsrReactRefreshUtils && typeof tsrReactRefreshUtils.enqueueUpdate === 'function'
+          ? tsrReactRefreshUtils.enqueueUpdate
+          : undefined
+      if (tsrEnqueueUpdate) {
+        tsrEnqueueUpdate(() => {})
+      }
+    } catch (_err) { /* noop */ }`
+			: '';
+	return [
+		template.statement(
+			`
+if (import.meta.webpackHot) {
+  const hot = import.meta.webpackHot
+  const hotData = hot.data ??= {}
+  const routeSignature = ${routeSignature}
+  const previousRouteSignature = hotData['tsr-route-signature']
+  const shouldInvalidateRoute = ${shouldInvalidateRoute}
+  hotData['tsr-route-signature'] = routeSignature
+  const routeId = hotData['tsr-route-id'] ?? Route.id ?? (Route.isRoot ? '__root__' : ${staticRouteIdLiteral})
+  if (routeId) {
+    hotData['tsr-route-id'] = routeId
+  }
+  const existingRoute =
+    typeof window !== 'undefined' && routeId
+      ? window.__TSR_ROUTER__?.routesById?.[routeId]
+      : undefined
+  if (routeId && existingRoute && existingRoute !== Route) {
+    (${handleRouteUpdateCode})(routeId, Route, shouldInvalidateRoute)${reactRefreshCall}
+  }
+  hot.dispose((data) => {
+    if (routeId) {
+      data['tsr-route-id'] = routeId
+    }
+    data['tsr-route-signature'] = routeSignature
+  })
+  hot.accept()
+}
+`,
+			{ syntacticPlaceholders: true },
+		)(),
+	];
+}
+//#endregion
+export { createWebpackHmrStatement };

package/src/internal/router-plugin/core/router-code-splitter-plugin.d.ts

@@ -0,0 +1,10 @@
+import { Config } from './config.js';
+import { RouterPluginContext } from './router-plugin-context.js';
+import { UnpluginFactory } from 'unplugin';
+export declare function createRouterCodeSplitterPlugin(
+	options: Partial<Config | (() => Config)> | undefined,
+	routerPluginContext: RouterPluginContext,
+): ReturnType<UnpluginFactory<Partial<Config | (() => Config)> | undefined>>;
+export declare const unpluginRouterCodeSplitterFactory: UnpluginFactory<
+	Partial<Config | (() => Config)> | undefined
+>;

package/src/internal/router-plugin/core/router-code-splitter-plugin.js

@@ -0,0 +1,244 @@
+import { getConfig, splitGroupingsSchema } from './config.js';
+import {
+	defaultCodeSplitGroupings,
+	splitRouteIdentNodes,
+	tsrShared,
+	tsrSplit,
+} from './constants.js';
+import { debug, normalizePath, routeFactoryCallCodeFilter } from './utils.js';
+import {
+	compileCodeSplitReferenceRoute,
+	compileCodeSplitSharedRoute,
+	compileCodeSplitVirtualRoute,
+	computeSharedBindings,
+	detectCodeSplitGroupingsFromRoute,
+} from './code-splitter/compilers.js';
+import {
+	getReferenceRouteCompilerPlugins,
+	getVirtualRouteCompilerPlugins,
+} from './code-splitter/plugins/framework-plugins.js';
+import { createRouterPluginContext } from './router-plugin-context.js';
+import { validateFrameworkPluginOrder } from './framework-plugin-order.js';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { decodeIdentifier, logDiff } from '@tanstack/router-utils';
+//#region src/core/router-code-splitter-plugin.ts
+/**
+ * It is important to familiarize yourself with how the code-splitting works in this plugin.
+ * https://github.com/TanStack/router/pull/3355
+ */
+var CODE_SPLITTER_PLUGIN_NAME = 'tanstack-router:code-splitter:compile-reference-file';
+function createRouterCodeSplitterPlugin(options = {}, routerPluginContext) {
+	let ROOT = process.cwd();
+	let userConfig;
+	function initUserConfig() {
+		if (typeof options === 'function') userConfig = options();
+		else userConfig = getConfig(options, ROOT);
+	}
+	const isProduction = process.env.NODE_ENV === 'production';
+	const sharedBindingsMap = /* @__PURE__ */ new Map();
+	const getGlobalCodeSplitGroupings = () => {
+		return userConfig.codeSplittingOptions?.defaultBehavior || defaultCodeSplitGroupings;
+	};
+	const getShouldSplitFn = () => {
+		return userConfig.codeSplittingOptions?.splitBehavior;
+	};
+	const shouldAddHmr = () => {
+		return (userConfig.codeSplittingOptions?.addHmr ?? true) && !isProduction;
+	};
+	const handleCompilingReferenceFile = (code, id, generatorNodeInfo) => {
+		if (debug) console.info('Compiling Route: ', id);
+		const fromCode = detectCodeSplitGroupingsFromRoute({
+			code,
+			filename: id,
+		});
+		if (fromCode.groupings !== void 0) {
+			const res = splitGroupingsSchema.safeParse(fromCode.groupings);
+			if (!res.success) {
+				const message = res.error.issues.map((e) => e.message).join('. ');
+				throw new Error(`The groupings for the route "${id}" are invalid.\n${message}`);
+			}
+		}
+		const pluginSplitBehavior = getShouldSplitFn()?.({ routeId: generatorNodeInfo.routeId });
+		if (pluginSplitBehavior) {
+			const res = splitGroupingsSchema.safeParse(pluginSplitBehavior);
+			if (!res.success) {
+				const message = res.error.issues.map((e) => e.message).join('. ');
+				throw new Error(
+					`The groupings returned when using \`splitBehavior\` for the route "${id}" are invalid.\n${message}`,
+				);
+			}
+		}
+		const splitGroupings =
+			fromCode.groupings ?? pluginSplitBehavior ?? getGlobalCodeSplitGroupings();
+		const sharedBindings = computeSharedBindings({
+			code,
+			filename: id,
+			codeSplitGroupings: splitGroupings,
+		});
+		if (sharedBindings.size > 0) sharedBindingsMap.set(id, sharedBindings);
+		else sharedBindingsMap.delete(id);
+		const addHmr = shouldAddHmr();
+		const hmrStyle = userConfig.plugin?.hmr?.style ?? 'vite';
+		const compiledReferenceRoute = compileCodeSplitReferenceRoute({
+			code,
+			codeSplitGroupings: splitGroupings,
+			targetFramework: userConfig.target,
+			filename: id,
+			id,
+			deleteNodes: userConfig.codeSplittingOptions?.deleteNodes
+				? new Set(userConfig.codeSplittingOptions.deleteNodes)
+				: void 0,
+			addHmr,
+			hmrStyle,
+			hmrRouteId: generatorNodeInfo.routeId,
+			sharedBindings: sharedBindings.size > 0 ? sharedBindings : void 0,
+			compilerPlugins: [
+				...(getReferenceRouteCompilerPlugins({
+					targetFramework: userConfig.target,
+					addHmr,
+					hmrStyle,
+				}) ?? []),
+				...(userConfig.codeSplittingOptions?.compilerPlugins ?? []),
+			],
+		});
+		if (compiledReferenceRoute === null) {
+			if (debug) console.info(`No changes made to route "${id}", skipping code-splitting.`);
+			return null;
+		}
+		if (debug) {
+			logDiff(code, compiledReferenceRoute.code);
+			console.log('Output:\n', compiledReferenceRoute.code + '\n\n');
+		}
+		return compiledReferenceRoute;
+	};
+	const handleCompilingVirtualFile = (code, id) => {
+		if (debug) console.info('Splitting Route: ', id);
+		const [_, ...pathnameParts] = id.split('?');
+		const splitValue = new URLSearchParams(pathnameParts.join('?')).get(tsrSplit);
+		if (!splitValue)
+			throw new Error(`The split value for the virtual route "${id}" was not found.`);
+		const rawGrouping = decodeIdentifier(splitValue);
+		const grouping = [...new Set(rawGrouping)].filter((p) => splitRouteIdentNodes.includes(p));
+		const baseId = id.split('?')[0];
+		const result = compileCodeSplitVirtualRoute({
+			code,
+			filename: id,
+			splitTargets: grouping,
+			sharedBindings: sharedBindingsMap.get(baseId),
+			compilerPlugins: getVirtualRouteCompilerPlugins({
+				targetFramework: userConfig.target,
+				addHmr: shouldAddHmr(),
+				hmrStyle: userConfig.plugin?.hmr?.style ?? 'vite',
+			}),
+		});
+		if (debug) {
+			logDiff(code, result.code);
+			console.log('Output:\n', result.code + '\n\n');
+		}
+		return result;
+	};
+	return [
+		{
+			name: 'tanstack-router:code-splitter:compile-reference-file',
+			enforce: 'pre',
+			transform: {
+				filter: {
+					id: {
+						exclude: [tsrSplit, tsrShared],
+						include: [/\.(m|c)?(j|t)sx?$/, /\.tsrx(?:$|\?)/],
+					},
+					code: { include: routeFactoryCallCodeFilter },
+				},
+				handler(code, id) {
+					const normalizedId = normalizePath(id);
+					const generatorFileInfo = routerPluginContext.routesByFile.get(normalizedId);
+					if (generatorFileInfo)
+						return handleCompilingReferenceFile(code, normalizedId, generatorFileInfo);
+					return null;
+				},
+			},
+			vite: {
+				configResolved(config) {
+					ROOT = config.root;
+					initUserConfig();
+					validateFrameworkPluginOrder({
+						framework: userConfig.target,
+						plugins: config.plugins,
+						routerPluginName: CODE_SPLITTER_PLUGIN_NAME,
+					});
+				},
+				applyToEnvironment(environment) {
+					if (userConfig.plugin?.vite?.environmentName)
+						return userConfig.plugin.vite.environmentName === environment.name;
+					return true;
+				},
+			},
+			rspack() {
+				ROOT = process.cwd();
+				initUserConfig();
+			},
+			webpack() {
+				ROOT = process.cwd();
+				initUserConfig();
+			},
+		},
+		{
+			name: 'tanstack-router:code-splitter:compile-virtual-file',
+			enforce: 'pre',
+			transform: {
+				filter: { id: /tsr-split/ },
+				handler(code, id) {
+					const url = pathToFileURL(id);
+					url.searchParams.delete('v');
+					return handleCompilingVirtualFile(code, normalizePath(fileURLToPath(url)));
+				},
+			},
+			vite: {
+				applyToEnvironment(environment) {
+					if (userConfig.plugin?.vite?.environmentName)
+						return userConfig.plugin.vite.environmentName === environment.name;
+					return true;
+				},
+			},
+		},
+		{
+			name: 'tanstack-router:code-splitter:compile-shared-file',
+			enforce: 'pre',
+			transform: {
+				filter: { id: /tsr-shared/ },
+				handler(code, id) {
+					const url = pathToFileURL(id);
+					url.searchParams.delete('v');
+					const normalizedId = normalizePath(fileURLToPath(url));
+					const [baseId] = normalizedId.split('?');
+					if (!baseId) return null;
+					const sharedBindings = sharedBindingsMap.get(baseId);
+					if (!sharedBindings || sharedBindings.size === 0) return null;
+					if (debug) console.info('Compiling Shared Module: ', id);
+					const result = compileCodeSplitSharedRoute({
+						code,
+						sharedBindings,
+						filename: normalizedId,
+					});
+					if (debug) {
+						logDiff(code, result.code);
+						console.log('Output:\n', result.code + '\n\n');
+					}
+					return result;
+				},
+			},
+			vite: {
+				applyToEnvironment(environment) {
+					if (userConfig.plugin?.vite?.environmentName)
+						return userConfig.plugin.vite.environmentName === environment.name;
+					return true;
+				},
+			},
+		},
+	];
+}
+var unpluginRouterCodeSplitterFactory = (options = {}) => {
+	return createRouterCodeSplitterPlugin(options, createRouterPluginContext());
+};
+//#endregion
+export { createRouterCodeSplitterPlugin, unpluginRouterCodeSplitterFactory };

package/src/internal/router-plugin/core/router-composed-plugin.d.ts

@@ -0,0 +1,5 @@
+import { Config } from './config.js';
+import { UnpluginFactory } from 'unplugin';
+export declare const unpluginRouterComposedFactory: UnpluginFactory<
+	Partial<Config | (() => Config)> | undefined
+>;

package/src/internal/router-plugin/core/router-composed-plugin.js

@@ -0,0 +1,62 @@
+import { createRouterPluginContext } from './router-plugin-context.js';
+import { createRouterCodeSplitterPlugin } from './router-code-splitter-plugin.js';
+import { createRouterGeneratorPlugin } from './router-generator-plugin.js';
+import { createRouterHmrPlugin } from './router-hmr-plugin.js';
+import { getConfig } from '#tanstack-start/router-generator';
+//#region src/core/router-composed-plugin.ts
+var INLINE_CSS_DEFAULT_DEFINES = {
+	'process.env.TSS_INLINE_CSS_ENABLED': JSON.stringify('false'),
+	'import.meta.env.TSS_INLINE_CSS_ENABLED': JSON.stringify('false'),
+};
+function applyWebpackInlineCssDefaultDefinePlugin(compiler) {
+	new compiler.webpack.DefinePlugin(INLINE_CSS_DEFAULT_DEFINES).apply(compiler);
+}
+function applyRspackInlineCssDefaultDefinePlugin(compiler) {
+	new compiler.webpack.DefinePlugin(INLINE_CSS_DEFAULT_DEFINES).apply(compiler);
+}
+var unpluginRouterComposedFactory = (options = {}, _meta) => {
+	const ROOT = process.cwd();
+	const userConfig = getConfig(typeof options === 'function' ? options() : options, ROOT);
+	const routerPluginContext = createRouterPluginContext();
+	const getPlugin = (plugin) => {
+		if (!Array.isArray(plugin)) return [plugin];
+		return plugin;
+	};
+	const routerGenerator = getPlugin(createRouterGeneratorPlugin(options, routerPluginContext));
+	const routerCodeSplitter = getPlugin(
+		createRouterCodeSplitterPlugin(options, routerPluginContext),
+	);
+	const result = [
+		{
+			name: 'tanstack:router-inline-css-defaults',
+			vite: {
+				config() {
+					return { define: { ...INLINE_CSS_DEFAULT_DEFINES } };
+				},
+			},
+			webpack(compiler) {
+				applyWebpackInlineCssDefaultDefinePlugin(compiler);
+			},
+			rspack(compiler) {
+				applyRspackInlineCssDefaultDefinePlugin(compiler);
+			},
+			esbuild: {
+				config(options) {
+					options.define = {
+						...INLINE_CSS_DEFAULT_DEFINES,
+						...options.define,
+					};
+				},
+			},
+		},
+		...routerGenerator,
+	];
+	if (userConfig.autoCodeSplitting) result.push(...routerCodeSplitter);
+	if (!(process.env.NODE_ENV === 'production') && !userConfig.autoCodeSplitting) {
+		const routerHmr = getPlugin(createRouterHmrPlugin(options, routerPluginContext));
+		result.push(...routerHmr);
+	}
+	return result;
+};
+//#endregion
+export { unpluginRouterComposedFactory };

package/src/internal/router-plugin/core/router-generator-plugin.d.ts

@@ -0,0 +1,10 @@
+import { UnpluginFactory } from 'unplugin';
+import { Config } from './config.js';
+import { RouterPluginContext } from './router-plugin-context.js';
+export declare function createRouterGeneratorPlugin(
+	options: Partial<Config | (() => Config)> | undefined,
+	routerPluginContext: RouterPluginContext,
+): ReturnType<UnpluginFactory<Partial<Config | (() => Config)> | undefined>>;
+export declare const unpluginRouterGeneratorFactory: UnpluginFactory<
+	Partial<Config | (() => Config)> | undefined
+>;

package/src/internal/router-plugin/core/router-generator-plugin.js

@@ -0,0 +1,125 @@
+import { getConfig as getConfig$1 } from './config.js';
+import { createRouterPluginContext } from './router-plugin-context.js';
+import { validateFrameworkPluginOrder } from './framework-plugin-order.js';
+import { Generator, resolveConfigPath } from '#tanstack-start/router-generator';
+import { isAbsolute, join, normalize } from 'node:path';
+//#region src/core/router-generator-plugin.ts
+var PLUGIN_NAME = 'unplugin:router-generator';
+function createRouterGeneratorPlugin(options = {}, routerPluginContext) {
+	let ROOT = process.cwd();
+	let userConfig;
+	let generator;
+	const routeGenerationDisabled = () => userConfig.enableRouteGeneration === false;
+	const getRoutesDirectoryPath = () => {
+		return isAbsolute(userConfig.routesDirectory)
+			? userConfig.routesDirectory
+			: join(ROOT, userConfig.routesDirectory);
+	};
+	const initConfigAndGenerator = (opts) => {
+		if (opts?.root) ROOT = opts.root;
+		if (typeof options === 'function') userConfig = options();
+		else userConfig = getConfig$1(options, ROOT);
+		generator = new Generator({
+			config: userConfig,
+			root: ROOT,
+		});
+	};
+	const generate = async (opts) => {
+		if (routeGenerationDisabled()) return;
+		let generatorEvent = void 0;
+		if (opts) {
+			const filePath = normalize(opts.file);
+			if (filePath === resolveConfigPath({ configDirectory: ROOT })) {
+				initConfigAndGenerator();
+				return;
+			}
+			generatorEvent = {
+				path: filePath,
+				type: opts.event,
+			};
+		}
+		try {
+			await generator.run(generatorEvent);
+			routerPluginContext.routesByFile = generator.getRoutesByFileMap();
+		} catch (e) {
+			console.error(e);
+		}
+	};
+	return {
+		name: 'tanstack:router-generator',
+		enforce: 'pre',
+		async watchChange(id, { event }) {
+			await generate({
+				file: id,
+				event,
+			});
+		},
+		vite: {
+			async configResolved(config) {
+				initConfigAndGenerator({ root: config.root });
+				if (userConfig.target === 'octane')
+					validateFrameworkPluginOrder({
+						framework: userConfig.target,
+						plugins: config.plugins,
+						routerPluginName: 'tanstack:router-generator',
+					});
+				await generate();
+			},
+		},
+		rspack(compiler) {
+			initConfigAndGenerator();
+			let handle = null;
+			compiler.hooks.beforeRun.tapPromise(PLUGIN_NAME, () => generate());
+			compiler.hooks.watchRun.tapPromise(PLUGIN_NAME, async () => {
+				if (handle) return;
+				const routesDirectoryPath = getRoutesDirectoryPath();
+				handle = (await import('chokidar'))
+					.watch(routesDirectoryPath, { ignoreInitial: true })
+					.on('add', (file) =>
+						generate({
+							file,
+							event: 'create',
+						}),
+					);
+				await generate();
+			});
+			compiler.hooks.watchClose.tap(PLUGIN_NAME, async () => {
+				if (handle) await handle.close();
+			});
+		},
+		webpack(compiler) {
+			initConfigAndGenerator();
+			let handle = null;
+			compiler.hooks.beforeRun.tapPromise(PLUGIN_NAME, () => generate());
+			compiler.hooks.watchRun.tapPromise(PLUGIN_NAME, async () => {
+				if (handle) return;
+				const routesDirectoryPath = getRoutesDirectoryPath();
+				handle = (await import('chokidar'))
+					.watch(routesDirectoryPath, { ignoreInitial: true })
+					.on('add', (file) =>
+						generate({
+							file,
+							event: 'create',
+						}),
+					);
+				await generate();
+			});
+			compiler.hooks.watchClose.tap(PLUGIN_NAME, async () => {
+				if (handle) await handle.close();
+			});
+			compiler.hooks.done.tap(PLUGIN_NAME, () => {
+				console.info('✅ unplugin:router-generator: route-tree generation done');
+			});
+		},
+		esbuild: {
+			config() {
+				initConfigAndGenerator();
+			},
+		},
+	};
+}
+var unpluginRouterGeneratorFactory = (options = {}) => {
+	return createRouterGeneratorPlugin(options, createRouterPluginContext());
+};
+//#endregion
+export { createRouterGeneratorPlugin, unpluginRouterGeneratorFactory };

package/src/internal/router-plugin/core/router-hmr-plugin.d.ts

@@ -0,0 +1,13 @@
+import { UnpluginFactory } from 'unplugin';
+import { Config } from './config.js';
+import { RouterPluginContext } from './router-plugin-context.js';
+/**
+ * This plugin adds HMR support for file routes.
+ * It is only added to the composed plugin in dev when autoCodeSplitting is disabled, since the code splitting plugin
+ * handles HMR for code-split routes itself.
+ */
+export declare function createRouterHmrPlugin(
+	options: Partial<Config | (() => Config)> | undefined,
+	routerPluginContext: RouterPluginContext,
+): ReturnType<UnpluginFactory<Partial<Config> | undefined>>;
+export declare const unpluginRouterHmrFactory: UnpluginFactory<Partial<Config> | undefined>;