@octanejs/tanstack-start 0.1.0

package/src/internal/router-generator/validate-route-params.d.ts

@@ -0,0 +1,13 @@
+import { Logger } from './logger.js';
+/**
+ * Validates route params and logs warnings for invalid param names.
+ *
+ * @param routePath - The route path to validate
+ * @param filePath - The file path for error messages
+ * @param logger - Logger instance for warnings
+ */
+export declare function validateRouteParams(
+	routePath: string,
+	filePath: string,
+	logger: Logger,
+): void;

package/src/internal/router-generator/validate-route-params.js

@@ -0,0 +1,75 @@
+//#region src/validate-route-params.ts
+/**
+ * Regex for valid JavaScript identifier (param name)
+ * Must start with letter, underscore, or dollar sign
+ * Can contain letters, numbers, underscores, or dollar signs
+ */
+var VALID_PARAM_NAME_REGEX = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+/**
+ * Extracts param names from a route path segment.
+ *
+ * Handles these patterns:
+ * - $paramName                     -> extract "paramName"
+ * - {$paramName}                   -> extract "paramName"
+ * - prefix{$paramName}suffix       -> extract "paramName"
+ * - {-$paramName}                  -> extract "paramName" (optional)
+ * - prefix{-$paramName}suffix      -> extract "paramName" (optional)
+ * - $ or {$}                       -> wildcard, skip validation
+ */
+function extractParamsFromSegment(segment) {
+	const params = [];
+	if (!segment || !segment.includes('$')) return params;
+	if (segment === '$' || segment === '{$}') return params;
+	if (segment.startsWith('$') && !segment.includes('{')) {
+		const paramName = segment.slice(1);
+		if (paramName)
+			params.push({
+				paramName,
+				isValid: VALID_PARAM_NAME_REGEX.test(paramName),
+			});
+		return params;
+	}
+	const bracePattern = /\{(-?\$)([^}]*)\}/g;
+	let match;
+	while ((match = bracePattern.exec(segment)) !== null) {
+		const paramName = match[2];
+		if (!paramName) continue;
+		params.push({
+			paramName,
+			isValid: VALID_PARAM_NAME_REGEX.test(paramName),
+		});
+	}
+	return params;
+}
+/**
+ * Extracts all params from a route path.
+ *
+ * @param path - The route path (e.g., "/users/$userId/posts/$postId")
+ * @returns Array of extracted params with validation info
+ */
+function extractParamsFromPath(path) {
+	if (!path || !path.includes('$')) return [];
+	const segments = path.split('/');
+	const allParams = [];
+	for (const segment of segments) {
+		const params = extractParamsFromSegment(segment);
+		allParams.push(...params);
+	}
+	return allParams;
+}
+/**
+ * Validates route params and logs warnings for invalid param names.
+ *
+ * @param routePath - The route path to validate
+ * @param filePath - The file path for error messages
+ * @param logger - Logger instance for warnings
+ */
+function validateRouteParams(routePath, filePath, logger) {
+	const invalidParams = extractParamsFromPath(routePath).filter((p) => !p.isValid);
+	for (const param of invalidParams)
+		logger.warn(
+			`WARNING: Invalid param name "${param.paramName}" in route "${routePath}" (file: ${filePath}). Param names must be valid JavaScript identifiers (match /[a-zA-Z_$][a-zA-Z0-9_$]*/).`,
+		);
+}
+//#endregion
+export { validateRouteParams };

package/src/internal/router-plugin/context.d.ts

@@ -0,0 +1,2 @@
+export { createRouterPluginContext } from './core/router-plugin-context.js';
+export type { RouterPluginContext } from './core/router-plugin-context.js';

package/src/internal/router-plugin/context.js

@@ -0,0 +1,2 @@
+import { createRouterPluginContext } from './core/router-plugin-context.js';
+export { createRouterPluginContext };

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

@@ -0,0 +1,69 @@
+import {
+	CompileCodeSplitReferenceRouteOptions,
+	ReferenceRouteCompilerPlugin,
+	VirtualRouteCompilerPlugin,
+} from './plugins.js';
+import { GeneratorResult, ParseAstOptions } from '@tanstack/router-utils';
+import { CodeSplitGroupings, SplitRouteIdentNodes } from '../constants.js';
+export {
+	buildDeclarationMap,
+	buildDependencyGraph,
+	collectIdentifiersFromNode,
+	collectLocalBindingsFromStatement,
+	collectModuleLevelRefsFromNode,
+	expandDestructuredDeclarations,
+	expandSharedDestructuredDeclarators,
+	expandTransitively,
+	removeBindingsTransitivelyDependingOn,
+} from '@tanstack/router-utils';
+export declare function removeBindingsDependingOnRoute(
+	bindings: Set<string>,
+	dependencyGraph: Map<string, Set<string>>,
+): void;
+export declare function addSharedSearchParamToFilename(filename: string): string;
+/**
+ * Computes module-level bindings that are shared between split and non-split
+ * route properties. These bindings need to be extracted into a shared virtual
+ * module to avoid double-initialization.
+ *
+ * A binding is "shared" if it is referenced by at least one split property
+ * AND at least one non-split property. Only locally-declared module-level
+ * bindings are candidates (not imports — bundlers dedupe those).
+ */
+export declare function computeSharedBindings(opts: {
+	code: string;
+	filename?: string;
+	codeSplitGroupings: CodeSplitGroupings;
+}): Set<string>;
+export declare function compileCodeSplitReferenceRoute(
+	opts: ParseAstOptions &
+		CompileCodeSplitReferenceRouteOptions & {
+			compilerPlugins?: Array<ReferenceRouteCompilerPlugin>;
+		},
+): GeneratorResult | null;
+export declare function compileCodeSplitVirtualRoute(
+	opts: ParseAstOptions & {
+		splitTargets: Array<SplitRouteIdentNodes>;
+		filename: string;
+		sharedBindings?: Set<string>;
+		compilerPlugins?: Array<VirtualRouteCompilerPlugin>;
+	},
+): GeneratorResult;
+/**
+ * Compile the shared virtual module (`?tsr-shared=1`).
+ * Keeps only shared binding declarations, their transitive dependencies,
+ * and imports they need. Exports all shared bindings.
+ */
+export declare function compileCodeSplitSharedRoute(
+	opts: ParseAstOptions & {
+		sharedBindings: Set<string>;
+		filename: string;
+	},
+): GeneratorResult;
+/**
+ * This function should read get the options from by searching for the key `codeSplitGroupings`
+ * on createFileRoute and return it's values if it exists, else return undefined
+ */
+export declare function detectCodeSplitGroupingsFromRoute(opts: ParseAstOptions): {
+	groupings: CodeSplitGroupings | undefined;
+};