@octanejs/tanstack-start 0.1.0

package/src/internal/router-generator/config.js

@@ -0,0 +1,134 @@
+import { virtualRootRouteSchema } from './filesystem/virtual/config.js';
+import path from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { z } from 'zod';
+//#region src/config.ts
+var tokenJsonRegexSchema = z.object({
+	regex: z.string(),
+	flags: z.string().optional(),
+});
+var tokenMatcherSchema = z.union([z.string(), z.instanceof(RegExp), tokenJsonRegexSchema]);
+var baseConfigSchema = z.object({
+	target: z.enum(['react', 'solid', 'vue', 'octane']).optional().default('react'),
+	virtualRouteConfig: virtualRootRouteSchema.or(z.string()).optional(),
+	routeFilePrefix: z.string().optional(),
+	routeFileIgnorePrefix: z.string().optional().default('-'),
+	routeFileIgnorePattern: z.string().optional(),
+	routesDirectory: z.string().optional().default('./src/routes'),
+	quoteStyle: z.enum(['single', 'double']).optional().default('single'),
+	semicolons: z.boolean().optional().default(false),
+	disableLogging: z.boolean().optional().default(false),
+	routeTreeFileHeader: z
+		.array(z.string())
+		.optional()
+		.default(['/* eslint-disable */', '// @ts-nocheck', '// noinspection JSUnusedGlobalSymbols']),
+	indexToken: tokenMatcherSchema.optional().default('index'),
+	routeToken: tokenMatcherSchema.optional().default('route'),
+	pathParamsAllowedCharacters: z.array(z.enum([';', ':', '@', '&', '=', '+', '$', ','])).optional(),
+});
+var configSchema = baseConfigSchema.extend({
+	generatedRouteTree: z.string().optional().default('./src/routeTree.gen.ts'),
+	disableTypes: z.boolean().optional().default(false),
+	addExtensions: z
+		.union([z.boolean(), z.string()])
+		.optional()
+		.default(false)
+		.transform((v) => (typeof v === 'string' ? (v.startsWith('.') ? v : `.${v}`) : v)),
+	enableRouteTreeFormatting: z.boolean().optional().default(true),
+	routeTreeFileFooter: z
+		.union([
+			z.array(z.string()).optional().default([]),
+			z.custom((value) => typeof value === 'function'),
+		])
+		.optional(),
+	autoCodeSplitting: z.boolean().optional(),
+	customScaffolding: z
+		.object({
+			routeTemplate: z.string().optional(),
+			lazyRouteTemplate: z.string().optional(),
+		})
+		.optional(),
+	experimental: z.object({ enableCodeSplitting: z.boolean().optional() }).optional(),
+	plugins: z.array(z.custom()).optional(),
+	tmpDir: z.string().optional().default(''),
+	importRoutesUsingAbsolutePaths: z.boolean().optional().default(false),
+});
+function resolveConfigPath({ configDirectory }) {
+	return path.resolve(configDirectory, 'tsr.config.json');
+}
+function getConfig(inlineConfig = {}, configDirectory) {
+	if (configDirectory === void 0) configDirectory = process.cwd();
+	const configFilePathJson = resolveConfigPath({ configDirectory });
+	const exists = existsSync(configFilePathJson);
+	let config;
+	let rawConfig;
+	if (exists) {
+		const merged = {
+			...JSON.parse(readFileSync(configFilePathJson, 'utf-8')),
+			...inlineConfig,
+		};
+		rawConfig = merged;
+		config = configSchema.parse(merged);
+	} else {
+		rawConfig = inlineConfig;
+		config = configSchema.parse(inlineConfig);
+	}
+	if (config.target === 'octane' && rawConfig.addExtensions === void 0) config.addExtensions = true;
+	if (config.disableTypes)
+		config.generatedRouteTree = config.generatedRouteTree.replace(/\.(ts|tsx)$/, '.js');
+	if (configDirectory)
+		if (path.isAbsolute(configDirectory)) {
+			config.routesDirectory = path.resolve(configDirectory, config.routesDirectory);
+			config.generatedRouteTree = path.resolve(configDirectory, config.generatedRouteTree);
+		} else {
+			config.routesDirectory = path.resolve(process.cwd(), configDirectory, config.routesDirectory);
+			config.generatedRouteTree = path.resolve(
+				process.cwd(),
+				configDirectory,
+				config.generatedRouteTree,
+			);
+		}
+	const resolveTmpDir = (dir) => {
+		if (Array.isArray(dir)) dir = path.join(...dir);
+		if (!path.isAbsolute(dir)) dir = path.resolve(process.cwd(), dir);
+		return dir;
+	};
+	if (config.tmpDir) config.tmpDir = resolveTmpDir(config.tmpDir);
+	else if (process.env.TSR_TMP_DIR) config.tmpDir = resolveTmpDir(process.env.TSR_TMP_DIR);
+	else config.tmpDir = resolveTmpDir(['.tanstack', 'tmp']);
+	validateConfig(config);
+	return config;
+}
+function validateConfig(config) {
+	if (typeof config.experimental?.enableCodeSplitting !== 'undefined') {
+		const message = `
+------
+⚠️ ⚠️ ⚠️
+ERROR: The "experimental.enableCodeSplitting" flag has been made stable and is now "autoCodeSplitting". Please update your configuration file to use "autoCodeSplitting" instead of "experimental.enableCodeSplitting".
+------
+`;
+		console.error(message);
+		throw new Error(message);
+	}
+	if (areTokensEqual(config.indexToken, config.routeToken))
+		throw new Error(`The "indexToken" and "routeToken" options must be different.`);
+	if (config.routeFileIgnorePrefix && config.routeFileIgnorePrefix.trim() === '_')
+		throw new Error(
+			`The "routeFileIgnorePrefix" cannot be an underscore ("_"). This is a reserved character used to denote a pathless route. Please use a different prefix.`,
+		);
+	return config;
+}
+/**
+ * Compares two token matchers for equality.
+ * Handles strings, RegExp instances, and JSON regex objects.
+ */
+function areTokensEqual(a, b) {
+	if (typeof a === 'string' && typeof b === 'string') return a === b;
+	if (a instanceof RegExp && b instanceof RegExp)
+		return a.source === b.source && a.flags === b.flags;
+	if (typeof a === 'object' && 'regex' in a && typeof b === 'object' && 'regex' in b)
+		return a.regex === b.regex && (a.flags ?? '') === (b.flags ?? '');
+	return false;
+}
+//#endregion
+export { baseConfigSchema, configSchema, getConfig, resolveConfigPath };

package/src/internal/router-generator/filesystem/physical/getRouteNodes.d.ts

@@ -0,0 +1,53 @@
+import { FsRouteType, GetRouteNodesResult } from '../../types.js';
+import { Config } from '../../config.js';
+/**
+ * Pre-compiled segment regexes for matching token patterns against route segments.
+ * These are created once (in Generator constructor) and passed through to avoid
+ * repeated regex compilation during route crawling.
+ */
+export interface TokenRegexBundle {
+	indexTokenSegmentRegex: RegExp;
+	routeTokenSegmentRegex: RegExp;
+}
+export declare function isVirtualConfigFile(fileName: string): boolean;
+export declare function getRouteNodes(
+	config: Pick<
+		Config,
+		| 'routesDirectory'
+		| 'routeFilePrefix'
+		| 'routeFileIgnorePrefix'
+		| 'routeFileIgnorePattern'
+		| 'disableLogging'
+		| 'routeToken'
+		| 'indexToken'
+	>,
+	root: string,
+	tokenRegexes: TokenRegexBundle,
+): Promise<GetRouteNodesResult>;
+/**
+ * Determines the metadata for a given route path based on the provided configuration.
+ *
+ * @param routePath - The determined initial routePath (with brackets removed).
+ * @param originalRoutePath - The original route path (may contain brackets for escaped content).
+ * @param tokenRegexes - Pre-compiled token regexes for matching.
+ * @returns An object containing the type of the route and the variable name derived from the route path.
+ */
+export declare function getRouteMeta(
+	routePath: string,
+	originalRoutePath: string,
+	tokenRegexes: TokenRegexBundle,
+): {
+	fsRouteType: Extract<
+		FsRouteType,
+		| 'static'
+		| 'layout'
+		| 'api'
+		| 'lazy'
+		| 'loader'
+		| 'component'
+		| 'pendingComponent'
+		| 'errorComponent'
+		| 'notFoundComponent'
+	>;
+	variableName: string;
+};

package/src/internal/router-generator/filesystem/physical/getRouteNodes.js

@@ -0,0 +1,335 @@
+import { logging } from '../../logger.js';
+import './rootPathId.js';
+import {
+	cleanPath,
+	createRoutePathSegmentMetadata,
+	determineInitialRoutePath,
+	escapeRegExp,
+	hasEscapedLeadingUnderscore,
+	joinRoutePathSegmentMetadata,
+	removeExt,
+	replaceBackslash,
+	routePathToVariable,
+	unwrapBracketWrappedSegment,
+} from '../../utils.js';
+import { loadConfigFile } from '../virtual/loadConfigFile.js';
+import { getRouteNodes as getRouteNodes$1 } from '../virtual/getRouteNodes.js';
+import path from 'node:path';
+import * as fsp from 'node:fs/promises';
+//#region src/filesystem/physical/getRouteNodes.ts
+var disallowedRouteGroupConfiguration = /\(([^)]+)\)\.(ts|js|tsx|jsx|vue|tsrx)$/;
+var virtualConfigFileRegExp = /__virtual\.[mc]?[jt]s$/;
+function isVirtualConfigFile(fileName) {
+	return virtualConfigFileRegExp.test(fileName);
+}
+async function getRouteNodes(config, root, tokenRegexes) {
+	const { routeFilePrefix, routeFileIgnorePrefix, routeFileIgnorePattern } = config;
+	const logger = logging({ disabled: config.disableLogging });
+	const routeFileIgnoreRegExp = new RegExp(routeFileIgnorePattern ?? '', 'g');
+	const routeNodes = [];
+	const allPhysicalDirectories = [];
+	async function recurse(dir) {
+		const fullDir = path.resolve(config.routesDirectory, dir);
+		let dirList = await fsp.readdir(fullDir, { withFileTypes: true });
+		dirList = dirList.filter((d) => {
+			if (
+				d.name.startsWith('.') ||
+				(routeFileIgnorePrefix && d.name.startsWith(routeFileIgnorePrefix))
+			)
+				return false;
+			if (routeFilePrefix) {
+				if (routeFileIgnorePattern)
+					return d.name.startsWith(routeFilePrefix) && !d.name.match(routeFileIgnoreRegExp);
+				return d.name.startsWith(routeFilePrefix);
+			}
+			if (routeFileIgnorePattern) return !d.name.match(routeFileIgnoreRegExp);
+			return true;
+		});
+		const virtualConfigFile = dirList.find((dirent) => {
+			return dirent.isFile() && isVirtualConfigFile(dirent.name);
+		});
+		if (virtualConfigFile !== void 0) {
+			const virtualRouteConfigExport = await loadConfigFile(
+				path.resolve(fullDir, virtualConfigFile.name),
+			);
+			let virtualRouteSubtreeConfig;
+			if (typeof virtualRouteConfigExport.default === 'function')
+				virtualRouteSubtreeConfig = await virtualRouteConfigExport.default();
+			else virtualRouteSubtreeConfig = virtualRouteConfigExport.default;
+			const dummyRoot = {
+				type: 'root',
+				file: '',
+				children: virtualRouteSubtreeConfig,
+			};
+			const { routeNodes: virtualRouteNodes, physicalDirectories } = await getRouteNodes$1(
+				{
+					...config,
+					routesDirectory: fullDir,
+					virtualRouteConfig: dummyRoot,
+				},
+				root,
+				tokenRegexes,
+			);
+			allPhysicalDirectories.push(...physicalDirectories);
+			virtualRouteNodes.forEach((node) => {
+				const normalizedDir = dir === './' ? '' : dir;
+				const filePath = replaceBackslash(path.join(normalizedDir, node.filePath));
+				const { routePath: prefixPath, originalRoutePath: originalPrefixPath } = normalizedDir
+					? determineInitialRoutePath(normalizedDir)
+					: {
+							routePath: '',
+							originalRoutePath: '',
+						};
+				const routePath = cleanPath(`${prefixPath}${node.routePath}`);
+				node.variableName = routePathToVariable(
+					cleanPath(`${prefixPath}/${removeExt(node.filePath)}`),
+				);
+				node._routePathSegmentMetadata = joinRoutePathSegmentMetadata(
+					routePath,
+					prefixPath,
+					createRoutePathSegmentMetadata(prefixPath, originalPrefixPath),
+					node._routePathSegmentMetadata,
+				);
+				node.routePath = routePath;
+				if (node.originalRoutePath)
+					node.originalRoutePath = cleanPath(`${originalPrefixPath}${node.originalRoutePath}`);
+				node.filePath = filePath;
+				delete node._virtualParentRoutePath;
+			});
+			routeNodes.push(...virtualRouteNodes);
+			return;
+		}
+		await Promise.all(
+			dirList.map(async (dirent) => {
+				const fullPath = replaceBackslash(path.join(fullDir, dirent.name));
+				const relativePath = path.posix.join(dir, dirent.name);
+				if (dirent.isDirectory()) await recurse(relativePath);
+				else if (fullPath.match(/\.(tsx|ts|jsx|js|vue|tsrx)$/)) {
+					const filePath = replaceBackslash(path.join(dir, dirent.name));
+					const { routePath: initialRoutePath, originalRoutePath: initialOriginalRoutePath } =
+						determineInitialRoutePath(removeExt(filePath));
+					let routePath = initialRoutePath;
+					let originalRoutePath = initialOriginalRoutePath;
+					if (routeFilePrefix) {
+						routePath = routePath.replaceAll(routeFilePrefix, '');
+						originalRoutePath = originalRoutePath.replaceAll(routeFilePrefix, '');
+					}
+					if (disallowedRouteGroupConfiguration.test(dirent.name)) {
+						const errorMessage = `A route configuration for a route group was found at \`${filePath}\`. This is not supported. Did you mean to use a layout/pathless route instead?`;
+						logger.error(`ERROR: ${errorMessage}`);
+						throw new Error(errorMessage);
+					}
+					const meta = getRouteMeta(routePath, originalRoutePath, tokenRegexes);
+					const variableName = meta.variableName;
+					let routeType = meta.fsRouteType;
+					if (routeType === 'lazy') {
+						routePath = routePath.replace(/\/lazy$/, '');
+						originalRoutePath = originalRoutePath.replace(/\/lazy$/, '');
+					}
+					if (isValidPathlessLayoutRoute(routePath, originalRoutePath, routeType, tokenRegexes))
+						routeType = 'pathless_layout';
+					if (!filePath.endsWith('.vue')) {
+						const extension = path.extname(filePath);
+						[
+							['component', 'component'],
+							['errorComponent', 'errorComponent'],
+							['notFoundComponent', 'notFoundComponent'],
+							['pendingComponent', 'pendingComponent'],
+							['loader', 'loader'],
+						].forEach(([matcher, type]) => {
+							if (routeType === matcher)
+								logger.warn(
+									`WARNING: The \`.${type}${extension}\` suffix used for the ${filePath} file is deprecated. Use the new \`.lazy${extension}\` suffix instead.`,
+								);
+						});
+					}
+					const originalSegments = originalRoutePath.split('/').filter(Boolean);
+					const lastOriginalSegmentForSuffix = originalSegments[originalSegments.length - 1] || '';
+					const { routeTokenSegmentRegex, indexTokenSegmentRegex } = tokenRegexes;
+					const specialSuffixes = [
+						'component',
+						'errorComponent',
+						'notFoundComponent',
+						'pendingComponent',
+						'loader',
+						'lazy',
+					];
+					const routePathSegments = routePath.split('/').filter(Boolean);
+					const lastRouteSegment = routePathSegments[routePathSegments.length - 1] || '';
+					const suffixToStrip = specialSuffixes.find((suffix) => {
+						const endsWithSuffix = routePath.endsWith(`/${suffix}`);
+						const isEscaped =
+							lastOriginalSegmentForSuffix.startsWith('[') &&
+							lastOriginalSegmentForSuffix.endsWith(']') &&
+							unwrapBracketWrappedSegment(lastOriginalSegmentForSuffix) === suffix;
+						return endsWithSuffix && !isEscaped;
+					});
+					const routeTokenCandidate = unwrapBracketWrappedSegment(lastOriginalSegmentForSuffix);
+					const isRouteTokenEscaped =
+						lastOriginalSegmentForSuffix !== routeTokenCandidate &&
+						routeTokenSegmentRegex.test(routeTokenCandidate);
+					const shouldStripRouteToken =
+						routeTokenSegmentRegex.test(lastRouteSegment) && !isRouteTokenEscaped;
+					if (suffixToStrip || shouldStripRouteToken) {
+						const stripSegment = suffixToStrip ?? lastRouteSegment;
+						routePath = routePath.replace(new RegExp(`/${escapeRegExp(stripSegment)}$`), '');
+						originalRoutePath = originalRoutePath.replace(
+							new RegExp(`/${escapeRegExp(stripSegment)}$`),
+							'',
+						);
+					}
+					const lastOriginalSegment = originalRoutePath.split('/').filter(Boolean).pop() || '';
+					const indexTokenCandidate = unwrapBracketWrappedSegment(lastOriginalSegment);
+					if (
+						!(
+							lastOriginalSegment !== indexTokenCandidate &&
+							indexTokenSegmentRegex.test(indexTokenCandidate)
+						)
+					) {
+						const updatedRouteSegments = routePath.split('/').filter(Boolean);
+						const updatedLastRouteSegment =
+							updatedRouteSegments[updatedRouteSegments.length - 1] || '';
+						if (indexTokenSegmentRegex.test(updatedLastRouteSegment)) {
+							if (routePathSegments.length === 1) routePath = '/';
+							const isLayoutRoute = routeType === 'layout';
+							routePath =
+								routePath.replace(new RegExp(`/${escapeRegExp(updatedLastRouteSegment)}$`), '/') ||
+								(isLayoutRoute ? '' : '/');
+							originalRoutePath =
+								originalRoutePath.replace(
+									new RegExp(`/${escapeRegExp(indexTokenCandidate)}$`),
+									'/',
+								) || (isLayoutRoute ? '' : '/');
+						}
+					}
+					routeNodes.push({
+						filePath,
+						fullPath,
+						routePath,
+						variableName,
+						_fsRouteType: routeType,
+						originalRoutePath,
+						_routePathSegmentMetadata: createRoutePathSegmentMetadata(routePath, originalRoutePath),
+					});
+				}
+			}),
+		);
+		return routeNodes;
+	}
+	await recurse('./');
+	const rootRouteNode =
+		routeNodes.find(
+			(d) =>
+				d.routePath === `/__root` &&
+				![
+					'component',
+					'errorComponent',
+					'notFoundComponent',
+					'pendingComponent',
+					'loader',
+					'lazy',
+				].includes(d._fsRouteType),
+		) ?? routeNodes.find((d) => d.routePath === `/__root`);
+	if (rootRouteNode) {
+		rootRouteNode._fsRouteType = '__root';
+		rootRouteNode.variableName = 'root';
+	}
+	return {
+		rootRouteNode,
+		routeNodes,
+		physicalDirectories: allPhysicalDirectories,
+	};
+}
+/**
+ * Determines the metadata for a given route path based on the provided configuration.
+ *
+ * @param routePath - The determined initial routePath (with brackets removed).
+ * @param originalRoutePath - The original route path (may contain brackets for escaped content).
+ * @param tokenRegexes - Pre-compiled token regexes for matching.
+ * @returns An object containing the type of the route and the variable name derived from the route path.
+ */
+function getRouteMeta(routePath, originalRoutePath, tokenRegexes) {
+	let fsRouteType = 'static';
+	const originalSegments = originalRoutePath.split('/').filter(Boolean);
+	const lastOriginalSegment = originalSegments[originalSegments.length - 1] || '';
+	const { routeTokenSegmentRegex } = tokenRegexes;
+	const isSuffixEscaped = (suffix) => {
+		return (
+			lastOriginalSegment.startsWith('[') &&
+			lastOriginalSegment.endsWith(']') &&
+			unwrapBracketWrappedSegment(lastOriginalSegment) === suffix
+		);
+	};
+	const routeSegments = routePath.split('/').filter(Boolean);
+	const lastRouteSegment = routeSegments[routeSegments.length - 1] || '';
+	const routeTokenCandidate = unwrapBracketWrappedSegment(lastOriginalSegment);
+	const isRouteTokenEscaped =
+		lastOriginalSegment !== routeTokenCandidate && routeTokenSegmentRegex.test(routeTokenCandidate);
+	if (routeTokenSegmentRegex.test(lastRouteSegment) && !isRouteTokenEscaped) fsRouteType = 'layout';
+	else if (routePath.endsWith('/lazy') && !isSuffixEscaped('lazy')) fsRouteType = 'lazy';
+	else if (routePath.endsWith('/loader') && !isSuffixEscaped('loader')) fsRouteType = 'loader';
+	else if (routePath.endsWith('/component') && !isSuffixEscaped('component'))
+		fsRouteType = 'component';
+	else if (routePath.endsWith('/pendingComponent') && !isSuffixEscaped('pendingComponent'))
+		fsRouteType = 'pendingComponent';
+	else if (routePath.endsWith('/errorComponent') && !isSuffixEscaped('errorComponent'))
+		fsRouteType = 'errorComponent';
+	else if (routePath.endsWith('/notFoundComponent') && !isSuffixEscaped('notFoundComponent'))
+		fsRouteType = 'notFoundComponent';
+	const variableName = routePathToVariable(
+		originalSegments.some(
+			(seg) =>
+				seg.startsWith('[') &&
+				seg.endsWith(']') &&
+				!seg.slice(1, -1).includes('[') &&
+				!seg.slice(1, -1).includes(']'),
+		)
+			? originalRoutePath
+			: routePath,
+	);
+	return {
+		fsRouteType,
+		variableName,
+	};
+}
+/**
+ * Used to validate if a route is a pathless layout route
+ * @param normalizedRoutePath Normalized route path, i.e `/foo/_layout/route.tsx` and `/foo._layout.route.tsx` to `/foo/_layout/route`
+ * @param originalRoutePath Original route path with brackets for escaped content
+ * @param routeType The route type determined from file extension
+ * @param tokenRegexes Pre-compiled token regexes for matching
+ * @returns Boolean indicating if the route is a pathless layout route
+ */
+function isValidPathlessLayoutRoute(
+	normalizedRoutePath,
+	originalRoutePath,
+	routeType,
+	tokenRegexes,
+) {
+	if (routeType === 'lazy') return false;
+	const segments = normalizedRoutePath.split('/').filter(Boolean);
+	const originalSegments = originalRoutePath.split('/').filter(Boolean);
+	if (segments.length === 0) return false;
+	const lastRouteSegment = segments[segments.length - 1];
+	const lastOriginalSegment = originalSegments[originalSegments.length - 1] || '';
+	const secondToLastRouteSegment = segments[segments.length - 2];
+	const secondToLastOriginalSegment = originalSegments[originalSegments.length - 2];
+	if (lastRouteSegment === '__root') return false;
+	const { routeTokenSegmentRegex, indexTokenSegmentRegex } = tokenRegexes;
+	if (
+		routeTokenSegmentRegex.test(lastRouteSegment) &&
+		typeof secondToLastRouteSegment === 'string' &&
+		typeof secondToLastOriginalSegment === 'string'
+	) {
+		if (hasEscapedLeadingUnderscore(secondToLastOriginalSegment)) return false;
+		return secondToLastRouteSegment.startsWith('_');
+	}
+	if (hasEscapedLeadingUnderscore(lastOriginalSegment)) return false;
+	return (
+		!indexTokenSegmentRegex.test(lastRouteSegment) &&
+		!routeTokenSegmentRegex.test(lastRouteSegment) &&
+		lastRouteSegment.startsWith('_')
+	);
+}
+//#endregion
+export { getRouteNodes, isVirtualConfigFile };

package/src/internal/router-generator/filesystem/physical/rootPathId.d.ts

@@ -0,0 +1 @@
+export declare const rootPathId = '__root';

package/src/internal/router-generator/filesystem/physical/rootPathId.js

@@ -0,0 +1,4 @@
+//#region src/filesystem/physical/rootPathId.ts
+var rootPathId = '__root';
+//#endregion
+export { rootPathId };

package/src/internal/router-generator/filesystem/virtual/config.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import { VirtualRootRoute } from '@tanstack/virtual-file-routes';
+export declare const virtualRootRouteSchema: z.ZodType<VirtualRootRoute>;

package/src/internal/router-generator/filesystem/virtual/config.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+//#region src/filesystem/virtual/config.ts
+var indexRouteSchema = z.object({
+	type: z.literal('index'),
+	file: z.string(),
+});
+var layoutRouteSchema = z.object({
+	type: z.literal('layout'),
+	id: z.string().optional(),
+	file: z.string(),
+	children: z.array(z.lazy(() => virtualRouteNodeSchema)).optional(),
+});
+var routeSchema = z.object({
+	type: z.literal('route'),
+	file: z.string().optional(),
+	path: z.string(),
+	children: z.array(z.lazy(() => virtualRouteNodeSchema)).optional(),
+});
+var physicalSubTreeSchema = z.object({
+	type: z.literal('physical'),
+	directory: z.string(),
+	pathPrefix: z.string(),
+});
+var virtualRouteNodeSchema = z.union([
+	indexRouteSchema,
+	layoutRouteSchema,
+	routeSchema,
+	physicalSubTreeSchema,
+]);
+var virtualRootRouteSchema = z.object({
+	type: z.literal('root'),
+	file: z.string(),
+	children: z.array(virtualRouteNodeSchema).optional(),
+});
+//#endregion
+export { virtualRootRouteSchema };

package/src/internal/router-generator/filesystem/virtual/getRouteNodes.d.ts

@@ -0,0 +1,31 @@
+import { VirtualRouteNode } from '@tanstack/virtual-file-routes';
+import { GetRouteNodesResult, RouteNode } from '../../types.js';
+import { Config } from '../../config.js';
+import { TokenRegexBundle } from '../physical/getRouteNodes.js';
+export declare function getRouteNodes(
+	tsrConfig: Pick<
+		Config,
+		| 'routesDirectory'
+		| 'virtualRouteConfig'
+		| 'routeFileIgnorePrefix'
+		| 'disableLogging'
+		| 'indexToken'
+		| 'routeToken'
+	>,
+	root: string,
+	tokenRegexes: TokenRegexBundle,
+): Promise<GetRouteNodesResult>;
+export declare function getRouteNodesRecursive(
+	tsrConfig: Pick<
+		Config,
+		'routesDirectory' | 'routeFileIgnorePrefix' | 'disableLogging' | 'indexToken' | 'routeToken'
+	>,
+	root: string,
+	fullDir: string,
+	nodes: Array<VirtualRouteNode> | undefined,
+	tokenRegexes: TokenRegexBundle,
+	parent?: RouteNode,
+): Promise<{
+	children: Array<RouteNode>;
+	physicalDirectories: Array<string>;
+}>;