@tanstack/start-plugin-core 1.169.12 → 1.169.14

package/dist/esm/start-compiler/compiler.js

@@ -10,9 +10,20 @@ import crypto from "node:crypto";
 import babel from "@babel/core";
 //#region src/start-compiler/compiler.ts
 function isLookupKind(kind) {
-	return kind in LookupSetup;
+	return kind in BuiltInLookupSetup || isExternalLookupKind(kind);
 }
-var LookupSetup = {
+function getExternalLookupKind(transform) {
+	return `External:${transform.name}`;
+}
+function isExternalLookupKind(kind) {
+	return typeof kind === "string" && kind.startsWith("External:");
+}
+function isCompilerTransformEnabledForEnv(transform, env) {
+	if (!transform.environment) return true;
+	if (Array.isArray(transform.environment)) return transform.environment.includes(env);
+	return transform.environment === env;
+}
+var BuiltInLookupSetup = {
 	ServerFn: {
 		type: "methodChain",
 		candidateCallIdentifier: new Set(["handler"])
@@ -31,11 +42,11 @@ var LookupSetup = {
 	},
 	ServerOnlyFn: {
 		type: "directCall",
-		factoryName: "createServerOnlyFn"
+		factoryNames: new Set(["createServerOnlyFn"])
 	},
 	ClientOnlyFn: {
 		type: "directCall",
-		factoryName: "createClientOnlyFn"
+		factoryNames: new Set(["createClientOnlyFn"])
 	},
 	ClientOnlyJSX: {
 		type: "jsx",
@@ -66,31 +77,47 @@ var LookupKindsPerEnv = {
 		"ClientOnlyJSX"
 	])
 };
+function getLookupKindsForEnv(env, opts) {
+	const kinds = new Set(LookupKindsPerEnv[env]);
+	for (const transform of opts?.compilerTransforms ?? []) if (isCompilerTransformEnabledForEnv(transform, env)) kinds.add(getExternalLookupKind(transform));
+	return kinds;
+}
 /**
 * Registry mapping each LookupKind to its handler function.
 * When adding a new kind, add its handler here.
 */
-var KindHandlers = {
+var BuiltInKindHandlers = {
 	ServerFn: handleCreateServerFn,
 	Middleware: handleCreateMiddleware,
 	IsomorphicFn: handleCreateIsomorphicFn,
 	ServerOnlyFn: handleEnvOnlyFn,
 	ClientOnlyFn: handleEnvOnlyFn
 };
-var AllLookupKinds = Object.keys(LookupSetup);
+var BuiltInKindHandlerOrder = [
+	"ServerFn",
+	"Middleware",
+	"IsomorphicFn",
+	"ServerOnlyFn",
+	"ClientOnlyFn"
+];
+var AllBuiltInLookupKinds = Object.keys(BuiltInLookupSetup);
 /**
 * 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.
 */
-function detectKindsInCode(code, env) {
+function detectKindsInCode(code, env, opts) {
 	const detected = /* @__PURE__ */ new Set();
-	const validForEnv = LookupKindsPerEnv[env];
-	for (const kind of AllLookupKinds) if (validForEnv.has(kind) && KindDetectionPatterns[kind].test(code)) detected.add(kind);
+	const validForEnv = getLookupKindsForEnv(env, opts);
+	for (const kind of AllBuiltInLookupKinds) if (validForEnv.has(kind) && KindDetectionPatterns[kind].test(code)) detected.add(kind);
+	for (const transform of opts?.compilerTransforms ?? []) {
+		if (!isCompilerTransformEnabledForEnv(transform, env)) continue;
+		if (transform.detect.test(code)) detected.add(getExternalLookupKind(transform));
+	}
 	return detected;
 }
 var IdentifierToKinds = /* @__PURE__ */ new Map();
-for (const kind of AllLookupKinds) {
-	const setup = LookupSetup[kind];
+for (const kind of AllBuiltInLookupKinds) {
+	const setup = BuiltInLookupSetup[kind];
 	if (setup.type === "methodChain") for (const id of setup.candidateCallIdentifier) {
 		let kinds = IdentifierToKinds.get(id);
 		if (!kinds) {
@@ -100,18 +127,9 @@ for (const kind of AllLookupKinds) {
 		kinds.add(kind);
 	}
 }
-var DirectCallFactoryNames = /* @__PURE__ */ new Set();
-for (const kind of AllLookupKinds) {
-	const setup = LookupSetup[kind];
-	if (setup.type === "directCall") DirectCallFactoryNames.add(setup.factoryName);
-}
-/**
-* Computes whether any file kinds need direct-call candidate detection.
-* This applies to directCall types (ServerOnlyFn, ClientOnlyFn).
-*/
-function needsDirectCallDetection(kinds) {
-	for (const kind of kinds) if (LookupSetup[kind].type === "directCall") return true;
-	return false;
+function getLookupSetup(kind, externalLookupSetup) {
+	if (kind in BuiltInLookupSetup) return BuiltInLookupSetup[kind];
+	if (isExternalLookupKind(kind)) return externalLookupSetup?.get(kind);
 }
 /**
 * Checks if all kinds in the set are guaranteed to be top-level only.
@@ -125,8 +143,8 @@ function areAllKindsTopLevelOnly(kinds) {
 /**
 * Checks if we need to detect JSX elements (e.g., <ClientOnly>).
 */
-function needsJSXDetection(kinds) {
-	for (const kind of kinds) if (LookupSetup[kind].type === "jsx") return true;
+function needsJSXDetection(kinds, externalLookupSetup) {
+	for (const kind of kinds) if (getLookupSetup(kind, externalLookupSetup)?.type === "jsx") return true;
 	return false;
 }
 /**
@@ -135,11 +153,17 @@ function needsJSXDetection(kinds) {
 * This is stricter than top-level detection because we need to filter out
 * invocations of existing server functions (e.g., `myServerFn()`).
 */
-function isNestedDirectCallCandidate(node) {
+function isNestedDirectCallCandidate(node, lookupKinds, externalLookupSetup) {
 	let calleeName;
 	if (t.isIdentifier(node.callee)) calleeName = node.callee.name;
 	else if (t.isMemberExpression(node.callee) && t.isIdentifier(node.callee.property)) calleeName = node.callee.property.name;
-	return calleeName !== void 0 && DirectCallFactoryNames.has(calleeName);
+	if (!calleeName) return false;
+	for (const kind of lookupKinds) {
+		if (isExternalLookupKind(kind)) continue;
+		const setup = getLookupSetup(kind, externalLookupSetup);
+		if (setup?.type === "directCall" && setup.factoryNames.has(calleeName)) return true;
+	}
+	return false;
 }
 function isSimpleDirectCallExpression(node) {
 	return t.isIdentifier(node.callee) || t.isMemberExpression(node.callee) && t.isIdentifier(node.callee.object) && t.isIdentifier(node.callee.property);
@@ -163,13 +187,43 @@ function isTopLevelDirectCallCandidate(path) {
 	if (!t.isVariableDeclaration(grandParent)) return false;
 	return t.isProgram(path.parentPath.parentPath?.parent);
 }
-function isDirectCallCandidateForKind(kind) {
-	return LookupSetup[kind].type === "directCall";
+function isDirectCallCandidateForKind(kind, externalLookupSetup) {
+	return getLookupSetup(kind, externalLookupSetup)?.type === "directCall";
+}
+function hasBuiltInDirectCallKinds(kinds) {
+	for (const kind of kinds) {
+		if (isExternalLookupKind(kind)) continue;
+		if (BuiltInLookupSetup[kind].type === "directCall") return true;
+	}
+	return false;
+}
+function hasExternalLookupKinds(kinds) {
+	for (const kind of kinds) if (isExternalLookupKind(kind)) return true;
+	return false;
+}
+function hasExternalDirectCallCandidates(candidates) {
+	return candidates.identifiers.size > 0 || candidates.namespaces.size > 0;
+}
+function getExternalDirectCallCandidateKind(path, candidates) {
+	const node = path.node;
+	if (t.isIdentifier(node.callee)) {
+		const kind = candidates.identifiers.get(node.callee.name);
+		if (!kind) return void 0;
+		return path.scope.getBinding(node.callee.name)?.path.isImportSpecifier() ? kind : void 0;
+	}
+	if (t.isMemberExpression(node.callee) && t.isIdentifier(node.callee.object) && t.isIdentifier(node.callee.property)) {
+		const kind = candidates.namespaces.get(node.callee.object.name)?.get(node.callee.property.name);
+		if (!kind) return void 0;
+		return path.scope.getBinding(node.callee.object.name)?.path.isImportNamespaceSpecifier() ? kind : void 0;
+	}
 }
 var StartCompiler = class {
 	moduleCache = /* @__PURE__ */ new Map();
 	initialized = false;
 	validLookupKinds;
+	externalTransformsByKind = /* @__PURE__ */ new Map();
+	externalLookupSetup = /* @__PURE__ */ new Map();
+	externalDirectCallKindsBySource = /* @__PURE__ */ new Map();
 	resolveIdCache = /* @__PURE__ */ new Map();
 	exportResolutionCache = /* @__PURE__ */ new Map();
 	knownRootImports = /* @__PURE__ */ new Map();
@@ -178,6 +232,25 @@ var StartCompiler = class {
 	constructor(options) {
 		this.options = options;
 		this.validLookupKinds = options.lookupKinds;
+		for (const transform of options.compilerTransforms ?? []) {
+			const kind = getExternalLookupKind(transform);
+			if (!this.validLookupKinds.has(kind)) continue;
+			this.externalTransformsByKind.set(kind, transform);
+			const factoryNames = /* @__PURE__ */ new Set();
+			for (const entry of transform.imports) {
+				factoryNames.add(entry.rootExport);
+				let rootExports = this.externalDirectCallKindsBySource.get(entry.libName);
+				if (!rootExports) {
+					rootExports = /* @__PURE__ */ new Map();
+					this.externalDirectCallKindsBySource.set(entry.libName, rootExports);
+				}
+				rootExports.set(entry.rootExport, kind);
+			}
+			this.externalLookupSetup.set(kind, {
+				type: "directCall",
+				factoryNames
+			});
+		}
 	}
 	/**
 	* Generates a unique function ID for a server function.
@@ -223,6 +296,31 @@ var StartCompiler = class {
 	get mode() {
 		return this.options.mode ?? "dev";
 	}
+	getExternalDirectCallCandidates(kinds, moduleInfo) {
+		const identifiers = /* @__PURE__ */ new Map();
+		const namespaces = /* @__PURE__ */ new Map();
+		if (this.externalDirectCallKindsBySource.size === 0) return {
+			identifiers,
+			namespaces
+		};
+		for (const [localName, binding] of moduleInfo.bindings) {
+			if (binding.type !== "import") continue;
+			const rootExports = this.externalDirectCallKindsBySource.get(binding.source);
+			if (!rootExports) continue;
+			if (binding.importedName === "*") {
+				const namespaceExports = /* @__PURE__ */ new Map();
+				for (const [rootExport, kind] of rootExports) if (kinds.has(kind)) namespaceExports.set(rootExport, kind);
+				if (namespaceExports.size > 0) namespaces.set(localName, namespaceExports);
+			} else {
+				const kind = rootExports.get(binding.importedName);
+				if (kind && kinds.has(kind)) identifiers.set(localName, kind);
+			}
+		}
+		return {
+			identifiers,
+			namespaces
+		};
+	}
 	async resolveIdCached(id, importer) {
 		if (this.mode === "dev") return this.options.resolveId(id, importer);
 		const cacheKey = importer ? `${importer}::${id}` : id;
@@ -259,7 +357,7 @@ var StartCompiler = class {
 			}
 			libExports.set(config.rootExport, config.kind);
 			if (config.kind !== "Root") {
-				if (LookupSetup[config.kind].type === "jsx") continue;
+				if (getLookupSetup(config.kind, this.externalLookupSetup)?.type === "jsx") continue;
 			}
 			const libId = config.libName;
 			let rootModule = this.moduleCache.get(libId);
@@ -422,7 +520,8 @@ var StartCompiler = class {
 		if (!this.initialized) await this.init();
 		const fileKinds = detectedKinds ? new Set([...detectedKinds].filter((k) => this.validLookupKinds.has(k))) : this.validLookupKinds;
 		if (fileKinds.size === 0) return null;
-		const checkDirectCalls = needsDirectCallDetection(fileKinds);
+		const hasExternalKinds = hasExternalLookupKinds(fileKinds);
+		const checkDirectCalls = hasBuiltInDirectCallKinds(fileKinds) || fileKinds.has("ServerFn") && !hasExternalKinds && hasBuiltInDirectCallKinds(this.validLookupKinds);
 		const canUseFastPath = areAllKindsTopLevelOnly(fileKinds);
 		const { ast } = this.ingestModule({
 			code,
@@ -431,8 +530,10 @@ var StartCompiler = class {
 		const candidatePaths = [];
 		const chainCallPaths = /* @__PURE__ */ new Map();
 		const jsxCandidatePaths = [];
-		const checkJSX = needsJSXDetection(fileKinds);
+		const checkJSX = needsJSXDetection(fileKinds, this.externalLookupSetup);
 		const moduleInfo = this.moduleCache.get(id);
+		const externalDirectCallCandidates = this.getExternalDirectCallCandidates(fileKinds, moduleInfo);
+		const checkExternalDirectCalls = hasExternalDirectCallCandidates(externalDirectCallCandidates);
 		if (canUseFastPath) {
 			const candidateIndices = [];
 			for (let i = 0; i < ast.program.body.length; i++) {
@@ -444,7 +545,7 @@ var StartCompiler = class {
 				}
 				if (declarations) {
 					for (const decl of declarations) if (decl.init && t.isCallExpression(decl.init)) {
-						if (isMethodChainCandidate(decl.init, fileKinds) || isTopLevelDirectCallCandidateNode(decl.init)) {
+						if (isMethodChainCandidate(decl.init, fileKinds) || checkDirectCalls && isTopLevelDirectCallCandidateNode(decl.init)) {
 							candidateIndices.push(i);
 							break;
 						}
@@ -465,10 +566,20 @@ var StartCompiler = class {
 							return;
 						}
 						if (isMethodChainCandidate(node, fileKinds)) {
-							candidatePaths.push(path);
+							candidatePaths.push({ path });
 							return;
 						}
-						if (isTopLevelDirectCallCandidate(path)) candidatePaths.push(path);
+						if (checkExternalDirectCalls) {
+							const kind = getExternalDirectCallCandidateKind(path, externalDirectCallCandidates);
+							if (kind) {
+								candidatePaths.push({
+									path,
+									kind
+								});
+								return;
+							}
+						}
+						if (isTopLevelDirectCallCandidate(path)) candidatePaths.push({ path });
 					} });
 				}
 				programPath.stop();
@@ -482,15 +593,28 @@ var StartCompiler = class {
 					return;
 				}
 				if (isMethodChainCandidate(node, fileKinds)) {
-					candidatePaths.push(path);
+					candidatePaths.push({ path });
 					return;
 				}
-				if (isTopLevelDirectCallCandidate(path)) {
-					candidatePaths.push(path);
+				if (checkExternalDirectCalls) {
+					const kind = getExternalDirectCallCandidateKind(path, externalDirectCallCandidates);
+					if (kind) {
+						candidatePaths.push({
+							path,
+							kind
+						});
+						return;
+					}
+				}
+				if (checkDirectCalls && isTopLevelDirectCallCandidate(path)) {
+					candidatePaths.push({ path });
 					return;
 				}
 				if (checkDirectCalls) {
-					if (isNestedDirectCallCandidate(node)) candidatePaths.push(path);
+					if (isNestedDirectCallCandidate(node, fileKinds, this.externalLookupSetup)) {
+						candidatePaths.push({ path });
+						return;
+					}
 				}
 			},
 			JSXElement: (path) => {
@@ -507,12 +631,20 @@ var StartCompiler = class {
 			}
 		});
 		if (candidatePaths.length === 0 && jsxCandidatePaths.length === 0) return null;
-		const validCandidates = (await Promise.all(candidatePaths.map(async (path) => ({
-			path,
-			kind: await this.resolveExprKind(path.node, id)
-		})))).filter(({ path, kind }) => {
+		const resolvedCandidates = [];
+		const unresolvedCandidates = [];
+		for (const candidate of candidatePaths) if (candidate.kind) resolvedCandidates.push({
+			path: candidate.path,
+			kind: candidate.kind
+		});
+		else unresolvedCandidates.push(candidate);
+		if (unresolvedCandidates.length > 0) resolvedCandidates.push(...await Promise.all(unresolvedCandidates.map(async (candidate) => ({
+			path: candidate.path,
+			kind: await this.resolveExprKind(candidate.path.node, id)
+		}))));
+		const validCandidates = resolvedCandidates.filter(({ path, kind }) => {
 			if (!this.validLookupKinds.has(kind)) return false;
-			if (isLookupKind(kind) && kind !== "ClientOnlyJSX" && !isMethodChainCandidate(path.node, fileKinds)) return isDirectCallCandidateForKind(kind);
+			if (isLookupKind(kind) && kind !== "ClientOnlyJSX" && !isMethodChainCandidate(path.node, fileKinds)) return isDirectCallCandidateForKind(kind, this.externalLookupSetup);
 			return true;
 		});
 		if (validCandidates.length === 0 && jsxCandidatePaths.length === 0) return null;
@@ -565,8 +697,11 @@ var StartCompiler = class {
 			root: this.options.root,
 			framework: this.options.framework,
 			providerEnvName: this.options.providerEnvName,
+			types: t,
+			parseExpression: (expressionCode) => babel.template.expression(expressionCode, { placeholderPattern: false })(),
 			generateFunctionId: (opts) => this.generateFunctionId(opts),
 			getKnownServerFns: this.options.getKnownServerFns,
+			serverFnProviderModuleDirectives: this.options.serverFnProviderModuleDirectives,
 			onServerFnsById: this.options.onServerFnsById
 		};
 		const candidatesByKind = /* @__PURE__ */ new Map();
@@ -579,10 +714,14 @@ var StartCompiler = class {
 			if (existing) existing.push(candidate);
 			else candidatesByKind.set(kind, [candidate]);
 		}
-		for (const [kind, candidates] of candidatesByKind) {
-			const handler = KindHandlers[kind];
+		this.runExternalTransforms("pre", candidatesByKind, context);
+		for (const kind of BuiltInKindHandlerOrder) {
+			const candidates = candidatesByKind.get(kind);
+			if (!candidates) continue;
+			const handler = BuiltInKindHandlers[kind];
 			handler(candidates, context, kind);
 		}
+		this.runExternalTransforms("post", candidatesByKind, context);
 		for (const jsxPath of jsxCandidatePaths) handleClientOnlyJSX(jsxPath, { env: "server" });
 		deadCodeElimination(ast, refIdents);
 		const result = generateFromAst(ast, {
@@ -593,6 +732,14 @@ var StartCompiler = class {
 		if (result.map) result.map.sourcesContent = [code];
 		return result;
 	}
+	runExternalTransforms(order, candidatesByKind, context) {
+		for (const [kind, transform] of this.externalTransformsByKind) {
+			if ((transform.order ?? "pre") !== order) continue;
+			const candidates = candidatesByKind.get(kind);
+			if (!candidates) continue;
+			transform.transform(candidates, context);
+		}
+	}
 	async resolveIdentifierKind(ident, id, visited = /* @__PURE__ */ new Set()) {
 		const binding = (await this.getModuleInfo(id)).bindings.get(ident);
 		if (!binding) return "None";
@@ -669,7 +816,7 @@ var StartCompiler = class {
 			return resolvedKind;
 		}
 		const resolvedKind = await this.resolveExprKind(binding.init, fileId, visited);
-		if (isLookupKind(resolvedKind) && LookupSetup[resolvedKind].type === "directCall" && binding.init && t.isCallExpression(binding.init)) {
+		if (isLookupKind(resolvedKind) && getLookupSetup(resolvedKind, this.externalLookupSetup)?.type === "directCall" && binding.init && t.isCallExpression(binding.init)) {
 			binding.resolvedKind = "None";
 			return "None";
 		}
@@ -715,6 +862,8 @@ var StartCompiler = class {
 			if (t.isIdentifier(callee.object)) {
 				const binding = (await this.getModuleInfo(fileId)).bindings.get(callee.object.name);
 				if (binding && binding.type === "import" && binding.importedName === "*") {
+					const knownKind = this.knownRootImports.get(binding.source)?.get(callee.property.name);
+					if (knownKind) return knownKind;
 					const targetModuleId = await this.resolveIdCached(binding.source, fileId);
 					if (targetModuleId) {
 						const targetModule = await this.getModuleInfo(targetModuleId);
@@ -753,6 +902,6 @@ function isMethodChainCandidate(node, lookupKinds) {
 	return false;
 }
 //#endregion
-export { KindDetectionPatterns, LookupKindsPerEnv, StartCompiler, detectKindsInCode };
+export { KindDetectionPatterns, StartCompiler, detectKindsInCode, getExternalLookupKind, getLookupKindsForEnv, isCompilerTransformEnabledForEnv };
 
 //# sourceMappingURL=compiler.js.map