@octanejs/tanstack-start 0.1.0

package/src/internal/start-plugin-core/vite/import-protection-plugin/types.d.ts

@@ -0,0 +1,103 @@
+import { CompileStartFrameworkOptions, GetConfigFn } from '../../types.js';
+import { ImportProtectionBehavior } from '../../schema.js';
+import { CompiledMatcher } from '../../import-protection/matchers.js';
+import { ImportGraph, ViolationInfo } from '../../import-protection/trace.js';
+import {
+	ImportLocCache,
+	TransformResult,
+	TransformResultProvider,
+} from '../../import-protection/sourceLocation.js';
+/** Compiled deny/exclude patterns for one environment (client or server). */
+export interface EnvRules {
+	specifiers: Array<CompiledMatcher>;
+	files: Array<CompiledMatcher>;
+	excludeFiles: Array<CompiledMatcher>;
+}
+export interface PluginConfig {
+	enabled: boolean;
+	root: string;
+	command: 'build' | 'serve';
+	bundledDev: boolean;
+	srcDirectory: string;
+	framework: CompileStartFrameworkOptions;
+	effectiveBehavior: ImportProtectionBehavior;
+	mockAccess: 'error' | 'warn' | 'off';
+	logMode: 'once' | 'always';
+	maxTraceDepth: number;
+	compiledRules: {
+		client: EnvRules;
+		server: EnvRules;
+	};
+	includeMatchers: Array<CompiledMatcher>;
+	excludeMatchers: Array<CompiledMatcher>;
+	ignoreImporterMatchers: Array<CompiledMatcher>;
+	markerSpecifiers: {
+		serverOnly: Set<string>;
+		clientOnly: Set<string>;
+	};
+	envTypeMap: Map<string, 'client' | 'server'>;
+	onViolation?: (info: ViolationInfo) => boolean | void | Promise<boolean | void>;
+}
+export interface EnvState {
+	graph: ImportGraph;
+	mockExportsByImporter: Map<string, Map<string, Array<string>>>;
+	resolveCache: Map<string, string | null>;
+	resolveCacheByFile: Map<string, Set<string>>;
+	importLocCache: ImportLocCache;
+	seenViolations: Set<string>;
+	serverFnLookupModules: Set<string>;
+	transformResultCache: Map<string, TransformResult>;
+	transformResultKeysByFile: Map<string, Set<string>>;
+	transformResultProvider: TransformResultProvider;
+	postTransformImports: Map<string, Set<string>>;
+	pendingViolations: Map<string, Array<PendingViolation>>;
+	deferredBuildViolations: Array<DeferredBuildViolation>;
+}
+export interface PendingViolation {
+	info: ViolationInfo;
+	/** True when the violation originates from a pre-transform resolveId call
+	 * (e.g. server-fn lookup).  These need edge-survival verification because
+	 * the Start compiler may strip the import later. */
+	fromPreTransformResolve?: boolean;
+}
+export interface DeferredBuildViolation {
+	info: ViolationInfo;
+	mockModuleId: string;
+	checkModuleId?: string;
+}
+export interface SharedState {
+	fileMarkerKind: Map<string, 'server' | 'client'>;
+}
+export interface ImportProtectionPluginOptions {
+	getConfig: GetConfigFn;
+	framework: CompileStartFrameworkOptions;
+	environments: Array<{
+		name: string;
+		type: 'client' | 'server';
+	}>;
+	providerEnvName: string;
+}
+export type ModuleGraphNode = {
+	id?: string | null;
+	url?: string;
+	importers: Set<ModuleGraphNode>;
+};
+export type ViolationReporter = {
+	warn: (msg: string) => void;
+	error: (msg: string) => never;
+	resolve?: (
+		source: string,
+		importer?: string,
+		options?: {
+			skipSelf?: boolean;
+			custom?: Record<string, unknown>;
+		},
+	) => Promise<{
+		id: string;
+		external?: boolean | 'absolute';
+	} | null>;
+	getModuleInfo?: (id: string) => {
+		code?: string | null;
+	} | null;
+};
+export type HandleViolationResult = string | undefined;

package/src/internal/start-plugin-core/vite/import-protection-plugin/virtualModules.d.ts

@@ -0,0 +1,40 @@
+import {
+	MARKER_PREFIX,
+	MOCK_BUILD_PREFIX,
+	MOCK_EDGE_PREFIX,
+	MOCK_MODULE_ID,
+	MOCK_RUNTIME_PREFIX,
+	RUNTIME_SUGGESTION_TEXT,
+	generateDevSelfDenialModule,
+	generateSelfContainedMockModule,
+	loadMarkerModule,
+	loadMockEdgeModule,
+	loadMockRuntimeModule,
+	loadSilentMockModule,
+	makeMockEdgeModuleId,
+	mockRuntimeModuleIdFromViolation,
+} from '../../import-protection/virtualModules.js';
+export declare function resolvedMarkerVirtualModuleId(kind: 'server' | 'client'): string;
+export declare function getResolvedVirtualModuleMatchers(): ReadonlyArray<string>;
+export declare function resolveInternalVirtualModuleId(source: string): string | undefined;
+export declare function loadResolvedVirtualModule(id: string):
+	| {
+			code: string;
+	  }
+	| undefined;
+export {
+	MARKER_PREFIX,
+	MOCK_BUILD_PREFIX,
+	MOCK_EDGE_PREFIX,
+	MOCK_MODULE_ID,
+	MOCK_RUNTIME_PREFIX,
+	RUNTIME_SUGGESTION_TEXT,
+	generateDevSelfDenialModule,
+	generateSelfContainedMockModule,
+	loadMarkerModule,
+	loadMockEdgeModule,
+	loadMockRuntimeModule,
+	loadSilentMockModule,
+	makeMockEdgeModuleId,
+	mockRuntimeModuleIdFromViolation,
+};

package/src/internal/start-plugin-core/vite/import-protection-plugin/virtualModules.js

@@ -0,0 +1,68 @@
+import { resolveViteId } from '../../utils.js';
+import {
+	MARKER_PREFIX,
+	MOCK_BUILD_PREFIX,
+	MOCK_EDGE_PREFIX,
+	MOCK_MODULE_ID,
+	MOCK_RUNTIME_PREFIX,
+	VITE_BROWSER_VIRTUAL_PREFIX,
+} from '../../import-protection/constants.js';
+import {
+	loadMarkerModule,
+	loadMockEdgeModule,
+	loadMockRuntimeModule,
+	loadSilentMockModule,
+} from '../../import-protection/virtualModules.js';
+//#region src/vite/import-protection-plugin/virtualModules.ts
+var RESOLVED_MOCK_MODULE_ID = resolveViteId(MOCK_MODULE_ID);
+var RESOLVED_MOCK_BUILD_PREFIX = resolveViteId(MOCK_BUILD_PREFIX);
+var RESOLVED_MOCK_EDGE_PREFIX = resolveViteId(MOCK_EDGE_PREFIX);
+var RESOLVED_MOCK_RUNTIME_PREFIX = resolveViteId(MOCK_RUNTIME_PREFIX);
+var RESOLVED_MARKER_PREFIX = resolveViteId(MARKER_PREFIX);
+var RESOLVED_MARKER_SERVER_ONLY = resolveViteId(`${MARKER_PREFIX}server-only`);
+var RESOLVED_MARKER_CLIENT_ONLY = resolveViteId(`${MARKER_PREFIX}client-only`);
+function resolvedMarkerVirtualModuleId(kind) {
+	return kind === 'server' ? RESOLVED_MARKER_SERVER_ONLY : RESOLVED_MARKER_CLIENT_ONLY;
+}
+function getResolvedVirtualModuleMatchers() {
+	return RESOLVED_VIRTUAL_MODULE_MATCHERS;
+}
+var RESOLVED_VIRTUAL_MODULE_MATCHERS = [
+	RESOLVED_MOCK_MODULE_ID,
+	RESOLVED_MOCK_BUILD_PREFIX,
+	RESOLVED_MOCK_EDGE_PREFIX,
+	RESOLVED_MOCK_RUNTIME_PREFIX,
+	RESOLVED_MARKER_PREFIX,
+];
+var RESOLVE_PREFIX_PAIRS = [
+	[MOCK_EDGE_PREFIX, RESOLVED_MOCK_EDGE_PREFIX],
+	[MOCK_RUNTIME_PREFIX, RESOLVED_MOCK_RUNTIME_PREFIX],
+	[MOCK_BUILD_PREFIX, RESOLVED_MOCK_BUILD_PREFIX],
+	[MARKER_PREFIX, RESOLVED_MARKER_PREFIX],
+];
+function resolveInternalVirtualModuleId(source) {
+	if (source.startsWith('/@id/__x00__'))
+		return resolveInternalVirtualModuleId(`\0${source.slice(VITE_BROWSER_VIRTUAL_PREFIX.length)}`);
+	if (source === 'tanstack-start-import-protection:mock' || source === RESOLVED_MOCK_MODULE_ID)
+		return RESOLVED_MOCK_MODULE_ID;
+	for (const [unresolvedPrefix, resolvedPrefix] of RESOLVE_PREFIX_PAIRS) {
+		if (source.startsWith(unresolvedPrefix)) return resolveViteId(source);
+		if (source.startsWith(resolvedPrefix)) return source;
+	}
+}
+function loadResolvedVirtualModule(id) {
+	if (id === RESOLVED_MOCK_MODULE_ID) return loadSilentMockModule();
+	if (id.startsWith(RESOLVED_MOCK_BUILD_PREFIX)) return loadSilentMockModule();
+	if (id.startsWith(RESOLVED_MOCK_EDGE_PREFIX))
+		return loadMockEdgeModule(id.slice(RESOLVED_MOCK_EDGE_PREFIX.length));
+	if (id.startsWith(RESOLVED_MOCK_RUNTIME_PREFIX))
+		return loadMockRuntimeModule(id.slice(RESOLVED_MOCK_RUNTIME_PREFIX.length));
+	if (id.startsWith(RESOLVED_MARKER_PREFIX)) return loadMarkerModule();
+}
+//#endregion
+export {
+	getResolvedVirtualModuleMatchers,
+	loadResolvedVirtualModule,
+	resolveInternalVirtualModuleId,
+	resolvedMarkerVirtualModuleId,
+};

package/src/internal/start-plugin-core/vite/index.d.ts

@@ -0,0 +1,13 @@
+export type {
+	TanStackStartVitePluginCoreOptions,
+	ViteRscForwardSsrResolverStrategy,
+} from './types.js';
+export type { TanStackStartViteInputConfig } from './schema.js';
+export type {
+	StartCompilerImportTransform,
+	StartCompilerTransformCandidate,
+	StartCompilerTransformContext,
+} from '../types.js';
+export { START_ENVIRONMENT_NAMES, VITE_ENVIRONMENT_NAMES } from '../constants.js';
+export { createVirtualModule } from './createVirtualModule.js';
+export { tanStackStartVite } from './plugin.js';

package/src/internal/start-plugin-core/vite/index.js

@@ -0,0 +1,4 @@
+import { START_ENVIRONMENT_NAMES, VITE_ENVIRONMENT_NAMES } from '../constants.js';
+import { createVirtualModule } from './createVirtualModule.js';
+import { tanStackStartVite } from './plugin.js';
+export { START_ENVIRONMENT_NAMES, VITE_ENVIRONMENT_NAMES, createVirtualModule, tanStackStartVite };

package/src/internal/start-plugin-core/vite/load-env-plugin/plugin.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from 'vite';
+export declare function loadEnvPlugin(): Plugin;

package/src/internal/start-plugin-core/vite/load-env-plugin/plugin.js

@@ -0,0 +1,13 @@
+import { loadEnv } from 'vite';
+//#region src/vite/load-env-plugin/plugin.ts
+function loadEnvPlugin() {
+	return {
+		name: 'tanstack-start-core:load-env',
+		enforce: 'pre',
+		configResolved(config) {
+			Object.assign(process.env, loadEnv(config.mode, config.root, ''));
+		},
+	};
+}
+//#endregion
+export { loadEnvPlugin };

package/src/internal/start-plugin-core/vite/output-directory.d.ts

@@ -0,0 +1,7 @@
+import type * as vite from 'vite';
+export declare function getClientOutputDirectory(
+	userConfig: vite.UserConfig | vite.ResolvedConfig,
+): string;
+export declare function getServerOutputDirectory(
+	userConfig: vite.UserConfig | vite.ResolvedConfig,
+): string;

package/src/internal/start-plugin-core/vite/output-directory.js

@@ -0,0 +1,18 @@
+import { VITE_ENVIRONMENT_NAMES } from '../constants.js';
+import { join } from 'pathe';
+//#region src/vite/output-directory.ts
+function getClientOutputDirectory(userConfig) {
+	return getOutputDirectory(userConfig, VITE_ENVIRONMENT_NAMES.client, 'client');
+}
+function getServerOutputDirectory(userConfig) {
+	return getOutputDirectory(userConfig, VITE_ENVIRONMENT_NAMES.server, 'server');
+}
+function getOutputDirectory(userConfig, environmentName, directoryName) {
+	const rootOutputDirectory = userConfig.build?.outDir ?? 'dist';
+	return (
+		userConfig.environments?.[environmentName]?.build?.outDir ??
+		join(rootOutputDirectory, directoryName)
+	);
+}
+//#endregion
+export { getClientOutputDirectory, getServerOutputDirectory };

package/src/internal/start-plugin-core/vite/planning.d.ts

@@ -0,0 +1,112 @@
+import { ENTRY_POINTS } from '../constants.js';
+import { CompileStartFrameworkOptions } from '../types.js';
+import { ResolvedStartEntryPlan } from '../planning.js';
+import type * as vite from 'vite';
+export interface ViteResolvedEntryAliases {
+	client: string;
+	server: string;
+	start: string;
+	router: string;
+	alias: Record<(typeof ENTRY_POINTS)[keyof typeof ENTRY_POINTS], string>;
+}
+export declare function createViteResolvedEntryAliases(opts: {
+	entryPaths: ResolvedStartEntryPlan['entryPaths'];
+}): ViteResolvedEntryAliases;
+export declare function createViteConfigPlan(opts: {
+	viteConfig: vite.UserConfig;
+	command: 'serve' | 'build';
+	framework: CompileStartFrameworkOptions;
+	entryAliases: ViteResolvedEntryAliases;
+	clientOutputDirectory: string;
+	serverOutputDirectory: string;
+	serverFnProviderEnv: string;
+	optimizeDepsExclude: Array<string>;
+	noExternal: Array<string>;
+}): {
+	environments: {
+		client: {
+			consumer: 'client';
+			build: {
+				rollupOptions: {
+					input: {
+						index: string;
+					};
+				};
+				rolldownOptions: {
+					input: {
+						index: string;
+					};
+				};
+				outDir: string;
+			};
+			optimizeDeps: {
+				exclude: string[];
+				entries: string[];
+			};
+		};
+		ssr: {
+			consumer: 'server';
+			build: {
+				outDir: string;
+				commonjsOptions: {
+					include: RegExp[];
+				};
+				copyPublicDir: boolean;
+				rollupOptions: {
+					input: any;
+				};
+				rolldownOptions: {
+					input: any;
+				};
+				ssr: true;
+			};
+			optimizeDeps: {
+				entries: string[];
+			};
+		};
+	};
+	resolve: {
+		noExternal: string[];
+		alias: {
+			'virtual:tanstack-start-client-entry': string;
+			'virtual:tanstack-start-server-entry': string;
+			'#tanstack-start-entry': string;
+			'#tanstack-router-entry': string;
+		};
+	};
+};
+export declare function createViteDefineConfig(opts: {
+	command: 'serve' | 'build';
+	mode: string | undefined;
+	serverFnBase: string;
+	routerBasepath: string;
+	spaEnabled: boolean | undefined;
+	devSsrStylesEnabled: boolean;
+	devSsrStylesBasepath: string;
+	inlineCssEnabled: boolean;
+	staticNodeEnv: boolean;
+	disableCsrfMiddlewareWarning: boolean;
+}): {
+	'process.env.NODE_ENV'?: string | undefined;
+	'process.env.TSS_DISABLE_CSRF_MIDDLEWARE_WARNING': 'false' | 'true';
+	'import.meta.env.TSS_DISABLE_CSRF_MIDDLEWARE_WARNING': 'false' | 'true';
+	'process.env.TSS_INLINE_CSS_ENABLED': 'false' | 'true';
+	'import.meta.env.TSS_INLINE_CSS_ENABLED': 'false' | 'true';
+	'process.env.TSS_DEV_SSR_STYLES_BASEPATH': string;
+	'import.meta.env.TSS_DEV_SSR_STYLES_BASEPATH': string;
+	'process.env.TSS_DEV_SSR_STYLES_ENABLED': 'false' | 'true';
+	'import.meta.env.TSS_DEV_SSR_STYLES_ENABLED': 'false' | 'true';
+	'process.env.TSS_DEV_SERVER': 'false' | 'true';
+	'import.meta.env.TSS_DEV_SERVER': 'false' | 'true';
+	'process.env.TSS_SHELL'?: 'false' | 'true' | undefined;
+	'import.meta.env.TSS_SHELL'?: 'false' | 'true' | undefined;
+	'process.env.TSS_ROUTER_BASEPATH': string;
+	'import.meta.env.TSS_ROUTER_BASEPATH': string;
+	'process.env.TSS_SERVER_FN_BASE': string;
+	'import.meta.env.TSS_SERVER_FN_BASE': string;
+};
+export declare function buildStartViteEnvironments(opts: {
+	builder: vite.ViteBuilder;
+	providerEnvironmentName: string;
+	ssrIsProvider: boolean;
+}): Promise<void>;

package/src/internal/start-plugin-core/vite/planning.js

@@ -0,0 +1,152 @@
+import { DEV_CLIENT_ENTRY, ENTRY_POINTS, START_ENVIRONMENT_NAMES } from '../constants.js';
+import { getBundlerOptions } from '../utils.js';
+import { join } from 'pathe';
+import { normalizePath } from 'vite';
+import { escapePath } from 'tinyglobby';
+import { getStartPackage } from '#tanstack-start/package-names';
+//#region src/vite/planning.ts
+function createViteResolvedEntryAliases(opts) {
+	const client = normalizePath(opts.entryPaths.client);
+	const server = normalizePath(opts.entryPaths.server);
+	const start = normalizePath(opts.entryPaths.start);
+	const router = normalizePath(opts.entryPaths.router);
+	return {
+		client,
+		server,
+		start,
+		router,
+		alias: {
+			[ENTRY_POINTS.client]: client,
+			[ENTRY_POINTS.server]: server,
+			[ENTRY_POINTS.start]: start,
+			[ENTRY_POINTS.router]: router,
+		},
+	};
+}
+function createViteConfigPlan(opts) {
+	return {
+		environments: {
+			[START_ENVIRONMENT_NAMES.client]: {
+				consumer: 'client',
+				build: (() => {
+					const bundlerOptions = {
+						input: { index: opts.command === 'serve' ? DEV_CLIENT_ENTRY : ENTRY_POINTS.client },
+					};
+					return {
+						rollupOptions: bundlerOptions,
+						rolldownOptions: bundlerOptions,
+						outDir: opts.clientOutputDirectory,
+					};
+				})(),
+				optimizeDeps: {
+					exclude: opts.optimizeDepsExclude,
+					entries: escapeEntries([opts.entryAliases.client, opts.entryAliases.router]),
+				},
+			},
+			[START_ENVIRONMENT_NAMES.server]: {
+				consumer: 'server',
+				build: {
+					ssr: true,
+					...(() => {
+						const bundlerOptions = {
+							input:
+								getBundlerOptions(
+									opts.viteConfig.environments?.[START_ENVIRONMENT_NAMES.server]?.build,
+								)?.input ?? opts.entryAliases.server,
+						};
+						return {
+							rollupOptions: bundlerOptions,
+							rolldownOptions: bundlerOptions,
+						};
+					})(),
+					outDir: opts.serverOutputDirectory,
+					commonjsOptions: { include: [/node_modules/] },
+					copyPublicDir:
+						opts.viteConfig.environments?.[START_ENVIRONMENT_NAMES.server]?.build?.copyPublicDir ??
+						false,
+				},
+				optimizeDeps: {
+					entries: escapeEntries([
+						opts.entryAliases.server,
+						opts.entryAliases.start,
+						opts.entryAliases.router,
+					]),
+				},
+			},
+			...(opts.serverFnProviderEnv !== START_ENVIRONMENT_NAMES.server && {
+				[opts.serverFnProviderEnv]: {
+					build: { outDir: join(opts.serverOutputDirectory, opts.serverFnProviderEnv) },
+					optimizeDeps: { entries: escapeEntries([opts.entryAliases.router]) },
+				},
+			}),
+		},
+		resolve: {
+			noExternal: ['@tanstack/start**', `${getStartPackage(opts.framework)}**`, ...opts.noExternal],
+			alias: { ...opts.entryAliases.alias },
+		},
+	};
+}
+function createViteDefineConfig(opts) {
+	return {
+		...defineReplaceEnv('TSS_SERVER_FN_BASE', opts.serverFnBase),
+		...defineReplaceEnv('TSS_ROUTER_BASEPATH', opts.routerBasepath),
+		...(opts.command === 'serve'
+			? defineReplaceEnv('TSS_SHELL', opts.spaEnabled ? 'true' : 'false')
+			: {}),
+		...defineReplaceEnv('TSS_DEV_SERVER', opts.command === 'serve' ? 'true' : 'false'),
+		...defineReplaceEnv('TSS_DEV_SSR_STYLES_ENABLED', opts.devSsrStylesEnabled ? 'true' : 'false'),
+		...defineReplaceEnv('TSS_DEV_SSR_STYLES_BASEPATH', opts.devSsrStylesBasepath),
+		...defineReplaceEnv('TSS_INLINE_CSS_ENABLED', opts.inlineCssEnabled ? 'true' : 'false'),
+		...defineReplaceEnv(
+			'TSS_DISABLE_CSRF_MIDDLEWARE_WARNING',
+			opts.disableCsrfMiddlewareWarning ? 'true' : 'false',
+		),
+		...(opts.command === 'build' && opts.staticNodeEnv
+			? {
+					'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || opts.mode || 'production'),
+				}
+			: {}),
+	};
+}
+async function buildStartViteEnvironments(opts) {
+	const client = getRequiredBuilderEnvironment(
+		opts.builder,
+		START_ENVIRONMENT_NAMES.client,
+		'Client environment not found',
+	);
+	const server = getRequiredBuilderEnvironment(
+		opts.builder,
+		START_ENVIRONMENT_NAMES.server,
+		'SSR environment not found',
+	);
+	if (!client.isBuilt) await opts.builder.build(client);
+	if (!server.isBuilt) await opts.builder.build(server);
+	if (opts.ssrIsProvider) return;
+	const providerEnv = getRequiredBuilderEnvironment(
+		opts.builder,
+		opts.providerEnvironmentName,
+		`Provider environment "${opts.providerEnvironmentName}" not found`,
+	);
+	if (!providerEnv.isBuilt) await opts.builder.build(providerEnv);
+}
+function escapeEntries(entries) {
+	return entries.map((entry) => escapePath(entry));
+}
+function defineReplaceEnv(key, value) {
+	return {
+		[`process.env.${key}`]: JSON.stringify(value),
+		[`import.meta.env.${key}`]: JSON.stringify(value),
+	};
+}
+function getRequiredBuilderEnvironment(builder, environmentName, errorMessage) {
+	const environment = builder.environments[environmentName];
+	if (!environment) throw new Error(errorMessage);
+	return environment;
+}
+//#endregion
+export {
+	buildStartViteEnvironments,
+	createViteConfigPlan,
+	createViteDefineConfig,
+	createViteResolvedEntryAliases,
+};

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

@@ -0,0 +1,7 @@
+import { TanStackStartVitePluginCoreOptions } from './types.js';
+import { TanStackStartViteInputConfig } from './schema.js';
+import { PluginOption } from 'vite';
+export declare function tanStackStartVite(
+	corePluginOpts: TanStackStartVitePluginCoreOptions,
+	startPluginOpts: TanStackStartViteInputConfig | undefined,
+): Array<PluginOption>;