@octanejs/tanstack-start 0.1.0

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

@@ -0,0 +1,11 @@
+import { Config } from '../config.js';
+type FrameworkOptions = {
+	package: string;
+	idents: {
+		createFileRoute: string;
+		lazyFn: string;
+		lazyRouteComponent: string;
+	};
+};
+export declare function getFrameworkOptions(framework: Config['target']): FrameworkOptions;
+export {};

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

@@ -0,0 +1,41 @@
+import { OCTANE_ROUTER_PACKAGE } from '#tanstack-start/package-names';
+//#region src/core/code-splitter/framework-options.ts
+var frameworkOptions = {
+	react: {
+		package: '@tanstack/react-router',
+		idents: {
+			createFileRoute: 'createFileRoute',
+			lazyFn: 'lazyFn',
+			lazyRouteComponent: 'lazyRouteComponent',
+		},
+	},
+	solid: {
+		package: '@tanstack/solid-router',
+		idents: {
+			createFileRoute: 'createFileRoute',
+			lazyFn: 'lazyFn',
+			lazyRouteComponent: 'lazyRouteComponent',
+		},
+	},
+	vue: {
+		package: '@tanstack/vue-router',
+		idents: {
+			createFileRoute: 'createFileRoute',
+			lazyFn: 'lazyFn',
+			lazyRouteComponent: 'lazyRouteComponent',
+		},
+	},
+	octane: {
+		package: OCTANE_ROUTER_PACKAGE,
+		idents: {
+			createFileRoute: 'createFileRoute',
+			lazyFn: 'lazyFn',
+			lazyRouteComponent: 'lazyRouteComponent',
+		},
+	},
+};
+function getFrameworkOptions(framework) {
+	return frameworkOptions[framework];
+}
+//#endregion
+export { getFrameworkOptions };

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

@@ -0,0 +1,12 @@
+import { ReferenceRouteCompilerPlugin, VirtualRouteCompilerPlugin } from '../plugins.js';
+import { Config, HmrStyle } from '../../config.js';
+export declare function getReferenceRouteCompilerPlugins(opts: {
+	targetFramework: Config['target'];
+	addHmr?: boolean;
+	hmrStyle?: HmrStyle;
+}): Array<ReferenceRouteCompilerPlugin> | undefined;
+export declare function getVirtualRouteCompilerPlugins(opts: {
+	targetFramework: Config['target'];
+	addHmr?: boolean;
+	hmrStyle?: HmrStyle;
+}): Array<VirtualRouteCompilerPlugin> | undefined;

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

@@ -0,0 +1,35 @@
+import { createReactRefreshIgnoredRouteExportsPlugin } from './react-refresh-ignored-route-exports.js';
+import { createReactRefreshRouteComponentsPlugin } from './react-refresh-route-components.js';
+import { createStableHmrSplitRouteComponentsPlugin } from './react-stable-hmr-split-route-components.js';
+import { createOctaneSplitRouteComponentsPlugin } from './octane-split-route-components.js';
+import { createOctaneHmrSplitRouteComponentsPlugin } from './octane-hmr-split-route-components.js';
+//#region src/core/code-splitter/plugins/framework-plugins.ts
+function getReferenceRouteCompilerPlugins(opts) {
+	switch (opts.targetFramework) {
+		case 'react':
+			if (opts.addHmr) {
+				const hmrStyle = opts.hmrStyle ?? 'vite';
+				return [
+					...(hmrStyle === 'vite' ? [createReactRefreshIgnoredRouteExportsPlugin()] : []),
+					createReactRefreshRouteComponentsPlugin(),
+					createStableHmrSplitRouteComponentsPlugin({ hmrStyle }),
+				];
+			}
+			return;
+		case 'octane':
+			return [
+				createOctaneSplitRouteComponentsPlugin(),
+				...(opts.addHmr
+					? [createStableHmrSplitRouteComponentsPlugin({ hmrStyle: opts.hmrStyle ?? 'vite' })]
+					: []),
+			];
+		default:
+			return;
+	}
+}
+function getVirtualRouteCompilerPlugins(opts) {
+	if (opts.targetFramework !== 'octane' || !opts.addHmr) return;
+	return [createOctaneHmrSplitRouteComponentsPlugin({ hmrStyle: opts.hmrStyle ?? 'vite' })];
+}
+//#endregion
+export { getReferenceRouteCompilerPlugins, getVirtualRouteCompilerPlugins };

package/src/internal/router-plugin/core/code-splitter/plugins/octane-hmr-split-route-components.d.ts

@@ -0,0 +1,5 @@
+import { HmrStyle } from '../../config.js';
+import { VirtualRouteCompilerPlugin } from '../plugins.js';
+export declare function createOctaneHmrSplitRouteComponentsPlugin(opts: {
+	hmrStyle: HmrStyle;
+}): VirtualRouteCompilerPlugin;

package/src/internal/router-plugin/core/code-splitter/plugins/octane-hmr-split-route-components.js

@@ -0,0 +1,106 @@
+import { getUniqueProgramIdentifier } from '../../utils.js';
+import * as t from '@babel/types';
+import * as template from '@babel/template';
+//#region src/core/code-splitter/plugins/octane-hmr-split-route-components.ts
+var buildViteHmrStatements = template.statements(
+	`
+    const %%candidateIdent%% = %%hmrIdent%%(%%componentIdent%%)
+    const %%hotIdent%% = import.meta.hot
+    const %%hotDataIdent%% = %%hotIdent%% ? (%%hotIdent%%.data ??= {}) : undefined
+    let %%stableIdent%% = %%candidateIdent%%
+    if (%%hotDataIdent%%?.[%%hotDataKey%%]) {
+      %%hotDataIdent%%[%%hotDataKey%%][%%hmrSymbolIdent%%].update(%%candidateIdent%%)
+      %%stableIdent%% = %%hotDataIdent%%[%%hotDataKey%%]
+    }
+    %%stableIdent%%.$$singleRoot = %%componentIdent%%.$$singleRoot
+    try { %%stableIdent%%.__oct_loc = %%componentIdent%%.__oct_loc } catch {}
+    if (%%hotIdent%%) {
+      %%hotDataIdent%%[%%hotDataKey%%] = %%stableIdent%%
+      import.meta.hot.accept()
+    }
+  `,
+	{ syntacticPlaceholders: true },
+);
+var buildWebpackHmrStatements = template.statements(
+	`
+    const %%candidateIdent%% = %%hmrIdent%%(%%componentIdent%%)
+    const %%hotIdent%% = import.meta.webpackHot
+    let %%stableIdent%% = %%candidateIdent%%
+    if (%%hotIdent%%?.data?.[%%hotDataKey%%]) {
+      %%hotIdent%%.data[%%hotDataKey%%][%%hmrSymbolIdent%%].update(%%candidateIdent%%)
+      %%stableIdent%% = %%hotIdent%%.data[%%hotDataKey%%]
+    }
+    %%stableIdent%%.$$singleRoot = %%componentIdent%%.$$singleRoot
+    try { %%stableIdent%%.__oct_loc = %%componentIdent%%.__oct_loc } catch {}
+    if (%%hotIdent%%) {
+      %%hotIdent%%.dispose((data) => {
+        data[%%hotDataKey%%] = %%stableIdent%%
+      })
+      %%hotIdent%%.accept()
+    }
+  `,
+	{ syntacticPlaceholders: true },
+);
+function capitalizeIdentifier(value) {
+	return value[0].toUpperCase() + value.slice(1);
+}
+function createOctaneHmrSplitRouteComponentsPlugin(opts) {
+	let hmrIdent;
+	let hmrSymbolIdent;
+	return {
+		name: 'octane-hmr-split-route-components',
+		onExportSplitRouteProperty(ctx) {
+			if (ctx.splitNodeMeta.splitStrategy !== 'lazyRouteComponent') return;
+			if (!hmrIdent || !hmrSymbolIdent) {
+				hmrIdent = getUniqueProgramIdentifier(ctx.programPath, 'TSROctaneHmr');
+				hmrSymbolIdent = getUniqueProgramIdentifier(ctx.programPath, 'TSROctaneHmrSymbol');
+				ctx.programPath.unshiftContainer(
+					'body',
+					t.importDeclaration(
+						[
+							t.importSpecifier(hmrIdent, t.identifier('hmr')),
+							t.importSpecifier(hmrSymbolIdent, t.identifier('HMR')),
+						],
+						t.stringLiteral('octane'),
+					),
+				);
+			}
+			const exportName = ctx.splitNodeMeta.exporterIdent;
+			const name = capitalizeIdentifier(exportName);
+			const componentIdent = t.identifier(ctx.localExporterIdent);
+			const candidateIdent = getUniqueProgramIdentifier(
+				ctx.programPath,
+				`TSROctane${name}Candidate`,
+			);
+			const stableIdent = getUniqueProgramIdentifier(ctx.programPath, `TSROctane${name}`);
+			const hotIdent = getUniqueProgramIdentifier(ctx.programPath, `TSROctane${name}Hot`);
+			const hotDataIdent = getUniqueProgramIdentifier(ctx.programPath, `TSROctane${name}HotData`);
+			const hotDataKey = t.stringLiteral(`tsr-octane-split-component:${exportName}`);
+			const statements =
+				opts.hmrStyle === 'webpack'
+					? buildWebpackHmrStatements({
+							candidateIdent,
+							componentIdent,
+							hmrIdent,
+							hmrSymbolIdent,
+							hotDataKey,
+							hotIdent,
+							stableIdent,
+						})
+					: buildViteHmrStatements({
+							candidateIdent,
+							componentIdent,
+							hmrIdent,
+							hmrSymbolIdent,
+							hotDataIdent,
+							hotDataKey,
+							hotIdent,
+							stableIdent,
+						});
+			ctx.programPath.pushContainer('body', statements);
+			return stableIdent;
+		},
+	};
+}
+//#endregion
+export { createOctaneHmrSplitRouteComponentsPlugin };

package/src/internal/router-plugin/core/code-splitter/plugins/octane-split-route-components.d.ts

@@ -0,0 +1,8 @@
+import { ReferenceRouteCompilerPlugin } from '../plugins.js';
+/**
+ * Octane emits component metadata as adjacent top-level statements. Once the
+ * component binding moves to a virtual route module, those statements must
+ * move with it instead of evaluating against a missing binding in the
+ * reference module.
+ */
+export declare function createOctaneSplitRouteComponentsPlugin(): ReferenceRouteCompilerPlugin;

package/src/internal/router-plugin/core/code-splitter/plugins/octane-split-route-components.js

@@ -0,0 +1,85 @@
+import * as t from '@babel/types';
+//#region src/core/code-splitter/plugins/octane-split-route-components.ts
+function isStaticMember(node, objectName, propertyName) {
+	return (
+		t.isMemberExpression(node) &&
+		!node.computed &&
+		t.isIdentifier(node.object, { name: objectName }) &&
+		t.isIdentifier(node.property, { name: propertyName })
+	);
+}
+function isOctaneSingleRootStamp(statement, componentName) {
+	if (!t.isExpressionStatement(statement)) return false;
+	const expression = statement.expression;
+	return (
+		t.isAssignmentExpression(expression, { operator: '=' }) &&
+		isStaticMember(expression.left, componentName, '$$singleRoot') &&
+		t.isBooleanLiteral(expression.right, { value: true })
+	);
+}
+function isOctaneWarmPlan(statement, componentName) {
+	if (!t.isExpressionStatement(statement)) return false;
+	const expression = statement.expression;
+	return (
+		t.isAssignmentExpression(expression, { operator: '=' }) &&
+		isStaticMember(expression.left, componentName, '__warm') &&
+		t.isArrowFunctionExpression(expression.right) &&
+		!expression.right.async &&
+		expression.right.params.length === 1 &&
+		t.isIdentifier(expression.right.params[0], { name: '__wp' })
+	);
+}
+function isOctaneLocationStamp(statement, componentName) {
+	if (
+		!t.isTryStatement(statement) ||
+		statement.finalizer ||
+		!statement.handler ||
+		statement.handler.param ||
+		statement.block.body.length !== 1 ||
+		statement.handler.body.body.length !== 0 ||
+		!statement.handler.body.innerComments?.some(
+			(comment) => comment.value.trim() === 'frozen component',
+		)
+	)
+		return false;
+	const [bodyStatement] = statement.block.body;
+	if (!t.isExpressionStatement(bodyStatement)) return false;
+	const expression = bodyStatement.expression;
+	if (
+		!t.isAssignmentExpression(expression, { operator: '=' }) ||
+		!isStaticMember(expression.left, componentName, '__oct_loc')
+	)
+		return false;
+	return (
+		(t.isStringLiteral(expression.right) && /:\d+:\d+$/.test(expression.right.value)) ||
+		(t.isMemberExpression(expression.right) &&
+			!expression.right.computed &&
+			t.isIdentifier(expression.right.property, { name: '__oct_loc' }))
+	);
+}
+function isOctaneCompilerCompanion(statement, componentName) {
+	return (
+		isOctaneSingleRootStamp(statement, componentName) ||
+		isOctaneWarmPlan(statement, componentName) ||
+		isOctaneLocationStamp(statement, componentName)
+	);
+}
+/**
+ * Octane emits component metadata as adjacent top-level statements. Once the
+ * component binding moves to a virtual route module, those statements must
+ * move with it instead of evaluating against a missing binding in the
+ * reference module.
+ */
+function createOctaneSplitRouteComponentsPlugin() {
+	return {
+		name: 'octane-split-route-components',
+		onSplitRouteProperty(ctx) {
+			if (!t.isIdentifier(ctx.prop.value)) return;
+			const componentName = ctx.prop.value.name;
+			for (const statementPath of ctx.programPath.get('body'))
+				if (isOctaneCompilerCompanion(statementPath.node, componentName)) statementPath.remove();
+		},
+	};
+}
+//#endregion
+export { createOctaneSplitRouteComponentsPlugin };

package/src/internal/router-plugin/core/code-splitter/plugins/react-refresh-ignored-route-exports.d.ts

@@ -0,0 +1,2 @@
+import { ReferenceRouteCompilerPlugin } from '../plugins.js';
+export declare function createReactRefreshIgnoredRouteExportsPlugin(): ReferenceRouteCompilerPlugin;

package/src/internal/router-plugin/core/code-splitter/plugins/react-refresh-ignored-route-exports.js

@@ -0,0 +1,55 @@
+import { getUniqueProgramIdentifier } from '../../utils.js';
+import * as t from '@babel/types';
+import * as template from '@babel/template';
+//#region src/core/code-splitter/plugins/react-refresh-ignored-route-exports.ts
+var buildReactRefreshIgnoredRouteExportsStatements = template.statements(
+	`
+const hot = import.meta.hot
+if (hot && typeof window !== 'undefined') {
+  hot.data ??= {}
+  const tsrReactRefresh = window.__TSR_REACT_REFRESH__ ??= (() => {
+    const ignoredExportsById = new Map()
+    const previousGetIgnoredExports = window.__getReactRefreshIgnoredExports
+
+    window.__getReactRefreshIgnoredExports = (ctx) => {
+      const ignoredExports = previousGetIgnoredExports?.(ctx) ?? []
+      const moduleIgnored = ignoredExportsById.get(ctx.id) ?? []
+      return [...ignoredExports, ...moduleIgnored]
+    }
+
+    return {
+      ignoredExportsById,
+    }
+  })()
+
+  tsrReactRefresh.ignoredExportsById.set(%%moduleId%%, ['Route'])
+}
+`,
+	{ syntacticPlaceholders: true },
+);
+/**
+ * A trivial component-shaped export that gives `@vitejs/plugin-react` a valid
+ * Fast Refresh boundary. Without at least one non-ignored component export,
+ * the module would be invalidated (full page reload) on every update even
+ * though our custom route HMR handler already manages the update.
+ */
+var buildRefreshAnchorStatement = template.statement(
+	`export function %%anchorName%%() { return null }`,
+	{ syntacticPlaceholders: true },
+);
+function createReactRefreshIgnoredRouteExportsPlugin() {
+	return {
+		name: 'react-refresh-ignored-route-exports',
+		onAddHmr(ctx) {
+			const anchorName = getUniqueProgramIdentifier(ctx.programPath, 'TSRFastRefreshAnchor');
+			ctx.programPath.pushContainer(
+				'body',
+				buildReactRefreshIgnoredRouteExportsStatements({ moduleId: t.stringLiteral(ctx.opts.id) }),
+			);
+			ctx.programPath.pushContainer('body', buildRefreshAnchorStatement({ anchorName }));
+			return { modified: true };
+		},
+	};
+}
+//#endregion
+export { createReactRefreshIgnoredRouteExportsPlugin };

package/src/internal/router-plugin/core/code-splitter/plugins/react-refresh-route-components.d.ts

@@ -0,0 +1,2 @@
+import { ReferenceRouteCompilerPlugin } from '../plugins.js';
+export declare function createReactRefreshRouteComponentsPlugin(): ReferenceRouteCompilerPlugin;

package/src/internal/router-plugin/core/code-splitter/plugins/react-refresh-route-components.js

@@ -0,0 +1,50 @@
+import { getObjectPropertyKeyName, getUniqueProgramIdentifier } from '../../utils.js';
+import * as t from '@babel/types';
+//#region src/core/code-splitter/plugins/react-refresh-route-components.ts
+var REACT_REFRESH_ROUTE_COMPONENT_IDENTS = new Set([
+	'component',
+	'shellComponent',
+	'pendingComponent',
+	'errorComponent',
+	'notFoundComponent',
+]);
+function hoistInlineRouteComponents(ctx) {
+	const hoistedDeclarations = [];
+	ctx.routeOptions.properties.forEach((prop) => {
+		if (!t.isObjectProperty(prop)) return;
+		const key = getObjectPropertyKeyName(prop);
+		if (!key || !REACT_REFRESH_ROUTE_COMPONENT_IDENTS.has(key)) return;
+		if (!t.isArrowFunctionExpression(prop.value) && !t.isFunctionExpression(prop.value)) return;
+		const hoistedIdentifier = getUniqueProgramIdentifier(
+			ctx.programPath,
+			`TSR${key[0].toUpperCase()}${key.slice(1)}`,
+		);
+		hoistedDeclarations.push(
+			t.variableDeclaration('const', [
+				t.variableDeclarator(hoistedIdentifier, t.cloneNode(prop.value, true)),
+			]),
+		);
+		prop.value = t.cloneNode(hoistedIdentifier);
+	});
+	if (hoistedDeclarations.length === 0) return false;
+	ctx.insertionPath.insertBefore(hoistedDeclarations);
+	return true;
+}
+function createReactRefreshRouteComponentsPlugin() {
+	return {
+		name: 'react-refresh-route-components',
+		getStableRouteOptionKeys() {
+			return [...REACT_REFRESH_ROUTE_COMPONENT_IDENTS];
+		},
+		onUnsplittableRoute(ctx) {
+			if (!ctx.opts.addHmr) return;
+			if (hoistInlineRouteComponents(ctx)) return { modified: true };
+		},
+		onAddHmr(ctx) {
+			if (!ctx.opts.addHmr) return;
+			if (hoistInlineRouteComponents(ctx)) return { modified: true };
+		},
+	};
+}
+//#endregion
+export { createReactRefreshRouteComponentsPlugin };

package/src/internal/router-plugin/core/code-splitter/plugins/react-stable-hmr-split-route-components.d.ts

@@ -0,0 +1,5 @@
+import { HmrStyle } from '../../config.js';
+import { ReferenceRouteCompilerPlugin } from '../plugins.js';
+export declare function createStableHmrSplitRouteComponentsPlugin(opts: {
+	hmrStyle: HmrStyle;
+}): ReferenceRouteCompilerPlugin;

package/src/internal/router-plugin/core/code-splitter/plugins/react-stable-hmr-split-route-components.js

@@ -0,0 +1,54 @@
+import { getUniqueProgramIdentifier } from '../../utils.js';
+import * as t from '@babel/types';
+import * as template from '@babel/template';
+//#region src/core/code-splitter/plugins/react-stable-hmr-split-route-components.ts
+function capitalizeIdentifier(str) {
+	return str[0].toUpperCase() + str.slice(1);
+}
+function createHotDataKey(exportName) {
+	return `tsr-split-component:${exportName}`;
+}
+var buildStableSplitComponentStatements = template.statements(
+	`
+    const %%stableComponentIdent%% = (() => {
+      const hot = %%hotExpression%%
+      const hotData = hot ? (hot.data ??= {}) : undefined
+      return hotData?.[%%hotDataKey%%] ?? %%lazyRouteComponentIdent%%(%%localImporterIdent%%, %%exporterIdent%%)
+    })()
+    if (%%hotExpression%%) {
+      ((%%hotExpression%%).data ??= {})[%%hotDataKey%%] = %%stableComponentIdent%%
+    }
+  `,
+	{ syntacticPlaceholders: true },
+);
+function hotExpressionAstFor(hmrStyle) {
+	return template.expression.ast(
+		hmrStyle === 'webpack' ? 'import.meta.webpackHot' : 'import.meta.hot',
+	);
+}
+function createStableHmrSplitRouteComponentsPlugin(opts) {
+	return {
+		name: 'react-stable-hmr-split-route-components',
+		onSplitRouteProperty(ctx) {
+			if (ctx.splitNodeMeta.splitStrategy !== 'lazyRouteComponent') return;
+			const stableComponentIdent = getUniqueProgramIdentifier(
+				ctx.programPath,
+				`TSRSplit${capitalizeIdentifier(ctx.splitNodeMeta.exporterIdent)}`,
+			);
+			const hotDataKey = createHotDataKey(ctx.splitNodeMeta.exporterIdent);
+			ctx.insertionPath.insertBefore(
+				buildStableSplitComponentStatements({
+					stableComponentIdent,
+					hotDataKey: t.stringLiteral(hotDataKey),
+					hotExpression: hotExpressionAstFor(opts.hmrStyle),
+					lazyRouteComponentIdent: t.identifier(ctx.lazyRouteComponentIdent),
+					localImporterIdent: t.identifier(ctx.splitNodeMeta.localImporterIdent),
+					exporterIdent: t.stringLiteral(ctx.splitNodeMeta.exporterIdent),
+				}),
+			);
+			return t.identifier(stableComponentIdent.name);
+		},
+	};
+}
+//#endregion
+export { createStableHmrSplitRouteComponentsPlugin };

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

@@ -0,0 +1,62 @@
+import { default as babel } from '@babel/core';
+import { Config, DeletableNodes, HmrStyle } from '../config.js';
+import { CodeSplitGroupings } from '../constants.js';
+import { SplitNodeMeta } from './types.js';
+import type * as t from '@babel/types';
+export type CompileCodeSplitReferenceRouteOptions = {
+	codeSplitGroupings: CodeSplitGroupings;
+	deleteNodes?: Set<DeletableNodes>;
+	targetFramework: Config['target'];
+	filename: string;
+	id: string;
+	addHmr?: boolean;
+	hmrStyle?: HmrStyle;
+	hmrRouteId?: string;
+	sharedBindings?: Set<string>;
+};
+export type ReferenceRouteCompilerPluginContext = {
+	programPath: babel.NodePath<t.Program>;
+	callExpressionPath: babel.NodePath<t.CallExpression>;
+	insertionPath: babel.NodePath;
+	routeOptions: t.ObjectExpression;
+	createRouteFn: string;
+	opts: CompileCodeSplitReferenceRouteOptions;
+};
+export type ReferenceRouteSplitPropertyCompilerPluginContext = {
+	programPath: babel.NodePath<t.Program>;
+	callExpressionPath: babel.NodePath<t.CallExpression>;
+	insertionPath: babel.NodePath;
+	routeOptions: t.ObjectExpression;
+	prop: t.ObjectProperty;
+	splitNodeMeta: SplitNodeMeta;
+	lazyRouteComponentIdent: string;
+	opts: CompileCodeSplitReferenceRouteOptions;
+};
+export type ReferenceRouteCompilerPluginResult = {
+	modified?: boolean;
+};
+export type ReferenceRouteCompilerPlugin = {
+	name: string;
+	getStableRouteOptionKeys?: () => Array<string>;
+	onRouteOptions?: (
+		ctx: ReferenceRouteCompilerPluginContext,
+	) => void | ReferenceRouteCompilerPluginResult;
+	onAddHmr?: (
+		ctx: ReferenceRouteCompilerPluginContext,
+	) => void | ReferenceRouteCompilerPluginResult;
+	onUnsplittableRoute?: (
+		ctx: ReferenceRouteCompilerPluginContext,
+	) => void | ReferenceRouteCompilerPluginResult;
+	onSplitRouteProperty?: (
+		ctx: ReferenceRouteSplitPropertyCompilerPluginContext,
+	) => void | t.Expression;
+};
+export type VirtualRouteCompilerPluginContext = {
+	programPath: babel.NodePath<t.Program>;
+	splitNodeMeta: SplitNodeMeta;
+	localExporterIdent: string;
+};
+export type VirtualRouteCompilerPlugin = {
+	name: string;
+	onExportSplitRouteProperty?: (ctx: VirtualRouteCompilerPluginContext) => void | t.Identifier;
+};

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

@@ -0,0 +1,9 @@
+import { SplitRouteIdentNodes } from '../constants.js';
+export type SplitStrategy = 'lazyFn' | 'lazyRouteComponent';
+export type SplitNodeMeta = {
+	routeIdent: SplitRouteIdentNodes;
+	splitStrategy: SplitStrategy;
+	localImporterIdent: string;
+	exporterIdent: string;
+	localExporterIdent: string;
+};