@octanejs/tanstack-start 0.1.0

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

@@ -0,0 +1,252 @@
+import path from 'node:path';
+import { z } from 'zod';
+import { configSchema, getConfig } from '#tanstack-start/router-plugin';
+//#region src/schema.ts
+var tsrConfig = configSchema
+	.omit({
+		autoCodeSplitting: true,
+		target: true,
+	})
+	.partial();
+var patternSchema = z.union([z.string(), z.instanceof(RegExp)]);
+var importProtectionBehaviorSchema = z.enum(['error', 'mock']);
+var importProtectionEnvRulesSchema = z.object({
+	specifiers: z.array(patternSchema).optional(),
+	files: z.array(patternSchema).optional(),
+	excludeFiles: z.array(patternSchema).optional(),
+});
+var importProtectionOptionsSchema = z
+	.object({
+		enabled: z.boolean().optional(),
+		behavior: z
+			.union([
+				importProtectionBehaviorSchema,
+				z.object({
+					dev: importProtectionBehaviorSchema.optional(),
+					build: importProtectionBehaviorSchema.optional(),
+				}),
+			])
+			.optional(),
+		/**
+		 * In `behavior: 'mock'`, control whether mocked imports emit a runtime
+		 * console diagnostic when accessed.
+		 *
+		 * - 'error': console.error(new Error(...)) (default)
+		 * - 'warn': console.warn(new Error(...))
+		 * - 'off': disable runtime diagnostics
+		 */
+		mockAccess: z.enum(['error', 'warn', 'off']).optional(),
+		onViolation: z.custom((value) => typeof value === 'function').optional(),
+		include: z.array(patternSchema).optional(),
+		exclude: z.array(patternSchema).optional(),
+		client: importProtectionEnvRulesSchema.optional(),
+		server: importProtectionEnvRulesSchema.optional(),
+		ignoreImporters: z.array(patternSchema).optional(),
+		maxTraceDepth: z.number().optional(),
+		log: z.enum(['once', 'always']).optional(),
+	})
+	.optional();
+function parseStartConfig(opts, corePluginOpts, root) {
+	const rawRouterOptions = (opts ?? {}).router ?? {};
+	const options = tanstackStartOptionsSchema.parse(opts);
+	const srcDirectory = options.srcDirectory;
+	const routesDirectory = path.resolve(
+		root,
+		srcDirectory,
+		rawRouterOptions.routesDirectory ?? 'routes',
+	);
+	const generatedRouteTree = path.resolve(
+		root,
+		srcDirectory,
+		rawRouterOptions.generatedRouteTree ?? 'routeTree.gen.ts',
+	);
+	return {
+		...options,
+		router: {
+			...options.router,
+			...getConfig(
+				{
+					...options.router,
+					target: corePluginOpts.framework,
+					routesDirectory,
+					generatedRouteTree,
+				},
+				root,
+			),
+			target: corePluginOpts.framework,
+		},
+	};
+}
+var pageSitemapOptionsSchema = z.object({
+	exclude: z.boolean().optional(),
+	priority: z.number().min(0).max(1).optional(),
+	changefreq: z
+		.enum(['always', 'hourly', 'daily', 'weekly', 'monthly', 'yearly', 'never'])
+		.optional(),
+	lastmod: z.union([z.string(), z.date()]).optional(),
+	alternateRefs: z
+		.array(
+			z.object({
+				href: z.string(),
+				hreflang: z.string(),
+			}),
+		)
+		.optional(),
+	images: z
+		.array(
+			z.object({
+				loc: z.string(),
+				caption: z.string().optional(),
+				title: z.string().optional(),
+			}),
+		)
+		.optional(),
+	news: z
+		.object({
+			publication: z.object({
+				name: z.string(),
+				language: z.string(),
+			}),
+			publicationDate: z.union([z.string(), z.date()]),
+			title: z.string(),
+		})
+		.optional(),
+});
+var pageBaseSchema = z.object({
+	path: z.string(),
+	sitemap: pageSitemapOptionsSchema.optional(),
+	fromCrawl: z.boolean().optional(),
+});
+var pagePrerenderOptionsSchema = z.object({
+	enabled: z.boolean().optional(),
+	outputPath: z.string().optional(),
+	autoSubfolderIndex: z.boolean().optional(),
+	crawlLinks: z.boolean().optional(),
+	retryCount: z.number().optional(),
+	retryDelay: z.number().optional(),
+	onSuccess: z.custom((value) => typeof value === 'function').optional(),
+	headers: z.record(z.string(), z.string()).optional(),
+});
+var spaSchema = z.object({
+	enabled: z.boolean().optional().default(true),
+	maskPath: z.string().optional().default('/'),
+	prerender: pagePrerenderOptionsSchema
+		.optional()
+		.prefault({})
+		.transform((opts) => ({
+			outputPath: opts.outputPath ?? '/_shell',
+			crawlLinks: false,
+			retryCount: 0,
+			...opts,
+			enabled: true,
+		})),
+});
+var inlineCssSchema = z
+	.union([
+		z.boolean(),
+		z.object({
+			/**
+			 * Inline route CSS into the server-rendered HTML response.
+			 *
+			 * @experimental This option is experimental!
+			 */
+			enabled: z.boolean().optional().default(true),
+			/**
+			 * Emit build-time templates that allow `transformAssets` to rewrite
+			 * `url(...)` references inside inlined CSS at runtime.
+			 */
+			transformAssets: z.boolean().optional().default(false),
+		}),
+	])
+	.optional()
+	.default(false)
+	.transform((value) => {
+		if (typeof value === 'boolean')
+			return {
+				enabled: value,
+				transformAssets: false,
+			};
+		return value;
+	});
+var pageSchema = pageBaseSchema.extend({ prerender: pagePrerenderOptionsSchema.optional() });
+var tanstackStartOptionsObjectSchema = z.object({
+	srcDirectory: z.string().optional().default('src'),
+	start: z.object({ entry: z.string().optional() }).optional().prefault({}),
+	router: z
+		.object({
+			entry: z.string().optional(),
+			basepath: z.string().optional(),
+		})
+		.and(tsrConfig.optional().prefault({}))
+		.optional()
+		.prefault({}),
+	client: z
+		.object({
+			entry: z.string().optional(),
+			base: z.string().optional().default('/_build'),
+		})
+		.optional()
+		.prefault({}),
+	server: z
+		.object({
+			entry: z.string().optional(),
+			build: z
+				.object({
+					staticNodeEnv: z.boolean().optional().default(true),
+					/**
+					 * Inline route CSS into the server-rendered HTML response.
+					 *
+					 * @experimental This option is experimental!
+					 */
+					inlineCss: inlineCssSchema,
+				})
+				.optional()
+				.prefault({}),
+		})
+		.optional()
+		.prefault({}),
+	serverFns: z
+		.object({
+			base: z.string().optional().default('/_serverFn'),
+			disableCsrfMiddlewareWarning: z.boolean().optional().default(false),
+			generateFunctionId: z.custom((value) => typeof value === 'function').optional(),
+		})
+		.optional()
+		.prefault({}),
+	pages: z.array(pageSchema).optional().default([]),
+	sitemap: z
+		.object({
+			enabled: z.boolean().optional().default(true),
+			host: z.string().optional(),
+			outputPath: z.string().optional().default('sitemap.xml'),
+		})
+		.optional(),
+	prerender: z
+		.object({
+			enabled: z.boolean().optional(),
+			concurrency: z.number().optional(),
+			filter: z.custom((value) => typeof value === 'function').optional(),
+			failOnError: z.boolean().optional(),
+			autoStaticPathsDiscovery: z.boolean().optional(),
+			maxRedirects: z.number().min(0).optional(),
+		})
+		.and(pagePrerenderOptionsSchema.optional())
+		.optional(),
+	dev: z
+		.object({
+			ssrStyles: z
+				.object({
+					enabled: z.boolean().optional().default(true),
+					basepath: z.string().optional(),
+				})
+				.optional()
+				.prefault({}),
+		})
+		.optional()
+		.prefault({}),
+	spa: spaSchema.optional(),
+	importProtection: importProtectionOptionsSchema,
+});
+var tanstackStartOptionsSchema = tanstackStartOptionsObjectSchema.optional().prefault({});
+//#endregion
+export { parseStartConfig, tanstackStartOptionsObjectSchema };

package/src/internal/start-plugin-core/serialization-adapters-module.d.ts

@@ -0,0 +1,18 @@
+import { SerializationAdapterConfig } from './types.js';
+export declare const EMPTY_SERIALIZATION_ADAPTERS_MODULE =
+	'export const pluginSerializationAdapters = []\nexport const hasPluginAdapters = false';
+interface ResolvedAdapterModule {
+	module: string;
+	export: string;
+	isFactory: boolean;
+	index: number;
+}
+export declare function resolveSerializationAdaptersForRuntime(opts: {
+	adapters: Array<SerializationAdapterConfig> | undefined;
+	runtime: 'client' | 'server';
+}): Array<ResolvedAdapterModule>;
+export declare function generateSerializationAdaptersModule(opts: {
+	adapters: Array<SerializationAdapterConfig> | undefined;
+	runtime: 'client' | 'server';
+}): string;
+export {};

package/src/internal/start-plugin-core/serialization-adapters-module.js

@@ -0,0 +1,37 @@
+//#region src/serialization-adapters-module.ts
+var EMPTY_SERIALIZATION_ADAPTERS_MODULE = `export const pluginSerializationAdapters = []
+export const hasPluginAdapters = false`;
+function resolveSerializationAdaptersForRuntime(opts) {
+	if (!opts.adapters?.length) return [];
+	const resolvedAdapters = [];
+	for (let i = 0; i < opts.adapters.length; i++) {
+		const adapter = opts.adapters[i];
+		if ('module' in adapter) {
+			resolvedAdapters.push({
+				module: adapter.module,
+				export: adapter.export,
+				isFactory: adapter.isFactory ?? true,
+				index: i,
+			});
+			continue;
+		}
+		const runtimeAdapter = opts.runtime === 'client' ? adapter.client : adapter.server;
+		if (!runtimeAdapter) continue;
+		resolvedAdapters.push({
+			module: runtimeAdapter.module,
+			export: runtimeAdapter.export,
+			isFactory: runtimeAdapter.isFactory ?? true,
+			index: i,
+		});
+	}
+	return resolvedAdapters;
+}
+function generateSerializationAdaptersModule(opts) {
+	const resolvedAdapters = resolveSerializationAdaptersForRuntime(opts);
+	if (resolvedAdapters.length === 0) return EMPTY_SERIALIZATION_ADAPTERS_MODULE;
+	return `${resolvedAdapters.map((adapter) => `import { ${adapter.export} as adapter${adapter.index} } from '${adapter.module}'`).join('\n')}
+export const pluginSerializationAdapters = [${resolvedAdapters.map((adapter) => (adapter.isFactory ? `...(Array.isArray(adapter${adapter.index}()) ? adapter${adapter.index}() : [adapter${adapter.index}()])` : `adapter${adapter.index}`)).join(', ')}]
+export const hasPluginAdapters = true`;
+}
+//#endregion
+export { generateSerializationAdaptersModule };

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

@@ -0,0 +1,181 @@
+import { DevServerFnModuleSpecifierEncoder, ServerFn } from './types.js';
+import { ModuleInfoBinding } from '@tanstack/router-utils';
+import {
+	CompileStartFrameworkOptions,
+	StartCompilerEnvironment,
+	StartCompilerImportTransform,
+	StartCompilerPlugin,
+	StartCompilerTransformResult,
+} from '../types.js';
+type Binding = ModuleInfoBinding & {
+	resolvedKind?: Kind;
+};
+type Kind = 'None' | `Root` | `Builder` | LookupKind;
+export type BuiltInLookupKind =
+	| 'ServerFn'
+	| 'Middleware'
+	| 'IsomorphicFn'
+	| 'ServerOnlyFn'
+	| 'ClientOnlyFn'
+	| 'ClientOnlyJSX';
+export type ExternalLookupKind = `External:${string}`;
+export type LookupKind = BuiltInLookupKind | ExternalLookupKind;
+export declare function getExternalLookupKind(
+	transform: StartCompilerImportTransform,
+): ExternalLookupKind;
+export declare function isCompilerTransformEnabledForEnv(
+	transform: StartCompilerImportTransform,
+	env: StartCompilerEnvironment,
+): boolean;
+export declare function isStartCompilerPluginEnabledForEnv(
+	plugin: StartCompilerPlugin,
+	env: StartCompilerEnvironment,
+): boolean;
+export declare const KindDetectionPatterns: Record<BuiltInLookupKind, RegExp>;
+export declare const LookupKindsPerEnv: Record<'client' | 'server', Set<BuiltInLookupKind>>;
+export declare function getLookupKindsForEnv(
+	env: 'client' | 'server',
+	opts?: {
+		compilerTransforms?: Array<StartCompilerImportTransform> | undefined;
+	},
+): Set<LookupKind>;
+/**
+ * Detects which LookupKinds are present in the code using string matching.
+ * This is a fast pre-scan before AST parsing to limit the work done during compilation.
+ */
+export declare function detectKindsInCode(
+	code: string,
+	env: 'client' | 'server',
+	opts?: {
+		compilerTransforms?: Array<StartCompilerImportTransform> | undefined;
+	},
+): Set<LookupKind>;
+export type LookupConfig = {
+	libName: string;
+	rootExport: string;
+	kind: LookupKind | 'Root';
+};
+interface ModuleInfo {
+	id: string;
+	bindings: Map<string, Binding>;
+	exports: Map<string, string>;
+	reExportAllSources: Array<string>;
+}
+export declare class StartCompiler {
+	private options;
+	private moduleCache;
+	private initialized;
+	private validLookupKinds;
+	private externalTransformsByKind;
+	private externalLookupSetup;
+	private compilerPlugins;
+	private externalDirectCallKindsBySource;
+	private resolveIdCache;
+	private exportResolutionCache;
+	private knownRootImports;
+	private entryIdToFunctionId;
+	private functionIds;
+	constructor(options: {
+		env: 'client' | 'server';
+		envName: string;
+		root: string;
+		lookupConfigurations: Array<LookupConfig>;
+		lookupKinds: Set<LookupKind>;
+		loadModule: (id: string) => Promise<void>;
+		resolveId: (id: string, importer?: string) => Promise<string | null>;
+		/**
+		 * In 'build' mode, resolution results are cached for performance.
+		 * In 'dev' mode (default), caching is disabled to avoid invalidation complexity with HMR.
+		 */
+		mode?: 'dev' | 'build';
+		/**
+		 * The framework being used (e.g., 'react', 'solid').
+		 */
+		framework: CompileStartFrameworkOptions;
+		/**
+		 * The Vite environment name for the server function provider.
+		 */
+		providerEnvName: string;
+		/**
+		 * Custom function ID generator (optional, defaults to hash-based).
+		 */
+		generateFunctionId?: (opts: { filename: string; functionName: string }) => string | undefined;
+		/**
+		 * Callback when server functions are discovered.
+		 * Called after each file is compiled with its new functions.
+		 */
+		onServerFnsById?: (d: Record<string, ServerFn>) => void;
+		compilerTransforms?: Array<StartCompilerImportTransform> | undefined;
+		compilerPlugins?: Array<StartCompilerPlugin> | undefined;
+		serverFnProviderModuleDirectives?: ReadonlyArray<string> | undefined;
+		warn?: (message: string) => void;
+		/**
+		 * Returns the currently known server functions from previous builds.
+		 * Used by server callers to look up canonical extracted filenames.
+		 */
+		getKnownServerFns: () => Record<string, ServerFn>;
+		devServerFnModuleSpecifierEncoder?: DevServerFnModuleSpecifierEncoder;
+	});
+	/**
+	 * Generates a unique function ID for a server function.
+	 * In dev mode, uses a base64-encoded JSON with file path and export name.
+	 * In build mode, uses SHA256 hash or custom generator.
+	 */
+	private generateFunctionId;
+	private get mode();
+	private getExternalDirectCallCandidates;
+	private resolveIdCached;
+	private getExportResolutionCache;
+	private init;
+	/**
+	 * Extracts bindings and exports from an already-parsed AST.
+	 */
+	private extractModuleInfo;
+	ingestModule({
+		code,
+		id,
+		parserFilename,
+	}: {
+		code: string;
+		id: string;
+		parserFilename?: string;
+	}): {
+		info: ModuleInfo;
+		ast: import('@tanstack/router-utils').ParseAstResult;
+	};
+	invalidateModule(id: string): boolean;
+	invalidateModules(ids: Iterable<string>): Set<string>;
+	getTransitiveImporters(ids: string | Iterable<string>): Promise<Set<string>>;
+	compile({
+		code,
+		id,
+		parserFilename,
+		detectedKinds,
+		warn,
+	}: {
+		code: string;
+		id: string;
+		parserFilename?: string;
+		/** Pre-detected kinds present in this file. If not provided, all valid kinds are checked. */
+		detectedKinds?: Set<LookupKind>;
+		warn?: (message: string) => void;
+	}): Promise<StartCompilerTransformResult | null>;
+	private generateResultFromAst;
+	private getAstTransformPluginsForCode;
+	private runAstTransforms;
+	private runExternalTransforms;
+	private resolveIdentifierKind;
+	/**
+	 * Recursively find an export in a module, following `export * from` chains.
+	 * Returns the module info and binding if found, or undefined if not found.
+	 */
+	private findExportInModule;
+	private resolveBindingTarget;
+	private resolveKnownImportKind;
+	private resolveImportKind;
+	private resolveBindingKind;
+	private resolveExprKind;
+	private resolveCalleeKind;
+	private getModuleInfo;
+}
+export {};