@tanstack/start-plugin-core 1.142.12 → 1.143.0

package/dist/esm/create-server-fn-plugin/compiler.d.ts

@@ -21,7 +21,7 @@ type ExportEntry = {
     targetId: string;
 };
 type Kind = 'None' | `Root` | `Builder` | LookupKind;
-export type LookupKind = 'ServerFn' | 'Middleware' | 'IsomorphicFn' | 'ServerOnlyFn' | 'ClientOnlyFn';
+export type LookupKind = 'ServerFn' | 'Middleware' | 'IsomorphicFn' | 'ServerOnlyFn' | 'ClientOnlyFn' | 'ClientOnlyJSX';
 export declare const KindDetectionPatterns: Record<LookupKind, RegExp>;
 export declare const LookupKindsPerEnv: Record<'client' | 'server', Set<LookupKind>>;
 /**
@@ -45,6 +45,8 @@ export declare class ServerFnCompiler {
     private moduleCache;
     private initialized;
     private validLookupKinds;
+    private resolveIdCache;
+    private exportResolutionCache;
     private knownRootImports;
     constructor(options: {
         env: 'client' | 'server';
@@ -53,8 +55,21 @@ export declare class ServerFnCompiler {
         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';
     });
+    private get mode();
+    private resolveIdCached;
+    private getExportResolutionCache;
     private init;
+    /**
+     * Extracts bindings and exports from an already-parsed AST.
+     * This is the core logic shared by ingestModule and ingestModuleFromAst.
+     */
+    private extractModuleInfo;
     ingestModule({ code, id }: {
         code: string;
         id: string;

package/dist/esm/create-server-fn-plugin/compiler.js

@@ -6,6 +6,7 @@ import { handleCreateServerFn } from "./handleCreateServerFn.js";
 import { handleCreateMiddleware } from "./handleCreateMiddleware.js";
 import { handleCreateIsomorphicFn } from "./handleCreateIsomorphicFn.js";
 import { handleEnvOnlyFn } from "./handleEnvOnly.js";
+import { handleClientOnlyJSX } from "./handleClientOnlyJSX.js";
 const LookupSetup = {
   ServerFn: {
     type: "methodChain",
@@ -22,14 +23,16 @@ const LookupSetup = {
     // createIsomorphicFn() alone is valid (returns no-op)
   },
   ServerOnlyFn: { type: "directCall" },
-  ClientOnlyFn: { type: "directCall" }
+  ClientOnlyFn: { type: "directCall" },
+  ClientOnlyJSX: { type: "jsx", componentName: "ClientOnly" }
 };
 const KindDetectionPatterns = {
   ServerFn: /\.handler\s*\(/,
   Middleware: /createMiddleware/,
   IsomorphicFn: /createIsomorphicFn/,
   ServerOnlyFn: /createServerOnlyFn/,
-  ClientOnlyFn: /createClientOnlyFn/
+  ClientOnlyFn: /createClientOnlyFn/,
+  ClientOnlyJSX: /<ClientOnly|import\s*\{[^}]*\bClientOnly\b/
 };
 const LookupKindsPerEnv = {
   client: /* @__PURE__ */ new Set([
@@ -43,7 +46,9 @@ const LookupKindsPerEnv = {
     "ServerFn",
     "IsomorphicFn",
     "ServerOnlyFn",
-    "ClientOnlyFn"
+    "ClientOnlyFn",
+    "ClientOnlyJSX"
+    // Only transform on server to remove children
   ])
 };
 function detectKindsInCode(code, env) {
@@ -77,12 +82,34 @@ const DirectCallFactoryNames = /* @__PURE__ */ new Set([
 function needsDirectCallDetection(kinds) {
   for (const kind of kinds) {
     const setup = LookupSetup[kind];
-    if (setup.type === "directCall" || setup.allowRootAsCandidate) {
+    if (setup.type === "directCall" || setup.type === "methodChain" && setup.allowRootAsCandidate) {
       return true;
     }
   }
   return false;
 }
+function areAllKindsTopLevelOnly(kinds) {
+  return kinds.size === 1 && kinds.has("ServerFn");
+}
+function needsJSXDetection(kinds) {
+  for (const kind of kinds) {
+    const setup = LookupSetup[kind];
+    if (setup.type === "jsx") {
+      return true;
+    }
+  }
+  return false;
+}
+function getJSXComponentNames(kinds) {
+  const names = /* @__PURE__ */ new Set();
+  for (const kind of kinds) {
+    const setup = LookupSetup[kind];
+    if (setup.type === "jsx") {
+      names.add(setup.componentName);
+    }
+  }
+  return names;
+}
 function isNestedDirectCallCandidate(node) {
   let calleeName;
   if (t.isIdentifier(node.callee)) {
@@ -116,10 +143,36 @@ class ServerFnCompiler {
   moduleCache = /* @__PURE__ */ new Map();
   initialized = false;
   validLookupKinds;
+  resolveIdCache = /* @__PURE__ */ new Map();
+  exportResolutionCache = /* @__PURE__ */ new Map();
   // Fast lookup for direct imports from known libraries (e.g., '@tanstack/react-start')
   // Maps: libName → (exportName → Kind)
   // This allows O(1) resolution for the common case without async resolveId calls
   knownRootImports = /* @__PURE__ */ new Map();
+  get mode() {
+    return this.options.mode ?? "dev";
+  }
+  async resolveIdCached(id, importer) {
+    if (this.mode === "dev") {
+      return this.options.resolveId(id, importer);
+    }
+    const cacheKey = importer ? `${importer}::${id}` : id;
+    const cached = this.resolveIdCache.get(cacheKey);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const resolved = await this.options.resolveId(id, importer);
+    this.resolveIdCache.set(cacheKey, resolved);
+    return resolved;
+  }
+  getExportResolutionCache(moduleId) {
+    let cache = this.exportResolutionCache.get(moduleId);
+    if (!cache) {
+      cache = /* @__PURE__ */ new Map();
+      this.exportResolutionCache.set(moduleId, cache);
+    }
+    return cache;
+  }
   async init() {
     this.knownRootImports.set(
       "@tanstack/start-fn-stubs",
@@ -137,7 +190,13 @@ class ServerFnCompiler {
           this.knownRootImports.set(config.libName, libExports);
         }
         libExports.set(config.rootExport, config.kind);
-        const libId = await this.options.resolveId(config.libName);
+        if (config.kind !== "Root") {
+          const setup = LookupSetup[config.kind];
+          if (setup.type === "jsx") {
+            return;
+          }
+        }
+        const libId = await this.resolveIdCached(config.libName);
         if (!libId) {
           throw new Error(`could not resolve "${config.libName}"`);
         }
@@ -171,8 +230,11 @@ class ServerFnCompiler {
     );
     this.initialized = true;
   }
-  ingestModule({ code, id }) {
-    const ast = parseAst({ code });
+  /**
+   * Extracts bindings and exports from an already-parsed AST.
+   * This is the core logic shared by ingestModule and ingestModuleFromAst.
+   */
+  extractModuleInfo(ast, id) {
     const bindings = /* @__PURE__ */ new Map();
     const exports = /* @__PURE__ */ new Map();
     const reExportAllSources = [];
@@ -257,6 +319,11 @@ class ServerFnCompiler {
       reExportAllSources
     };
     this.moduleCache.set(id, info);
+    return info;
+  }
+  ingestModule({ code, id }) {
+    const ast = parseAst({ code });
+    const info = this.extractModuleInfo(ast, id);
     return { info, ast };
   }
   invalidateModule(id) {
@@ -276,31 +343,102 @@ class ServerFnCompiler {
       return null;
     }
     const checkDirectCalls = needsDirectCallDetection(fileKinds);
+    const canUseFastPath = areAllKindsTopLevelOnly(fileKinds);
     const { ast } = this.ingestModule({ code, id });
     const candidatePaths = [];
     const chainCallPaths = /* @__PURE__ */ new Map();
-    babel.traverse(ast, {
-      CallExpression: (path) => {
-        const node = path.node;
-        const parent = path.parent;
-        if (t.isMemberExpression(parent) && t.isCallExpression(path.parentPath.parent)) {
-          chainCallPaths.set(node, path);
-          return;
+    const jsxCandidatePaths = [];
+    const checkJSX = needsJSXDetection(fileKinds);
+    const jsxTargetComponentNames = checkJSX ? getJSXComponentNames(fileKinds) : null;
+    const moduleInfo = this.moduleCache.get(id);
+    if (canUseFastPath) {
+      const candidateIndices = [];
+      for (let i = 0; i < ast.program.body.length; i++) {
+        const node = ast.program.body[i];
+        let declarations;
+        if (t.isVariableDeclaration(node)) {
+          declarations = node.declarations;
+        } else if (t.isExportNamedDeclaration(node) && node.declaration) {
+          if (t.isVariableDeclaration(node.declaration)) {
+            declarations = node.declaration.declarations;
+          }
         }
-        if (isMethodChainCandidate(node, fileKinds)) {
-          candidatePaths.push(path);
-          return;
+        if (declarations) {
+          for (const decl of declarations) {
+            if (decl.init && t.isCallExpression(decl.init)) {
+              if (isMethodChainCandidate(decl.init, fileKinds)) {
+                candidateIndices.push(i);
+                break;
+              }
+            }
+          }
         }
-        if (checkDirectCalls) {
-          if (isTopLevelDirectCallCandidate(path)) {
-            candidatePaths.push(path);
-          } else if (isNestedDirectCallCandidate(node)) {
+      }
+      if (candidateIndices.length === 0) {
+        return null;
+      }
+      babel.traverse(ast, {
+        Program(programPath) {
+          const bodyPaths = programPath.get("body");
+          for (const idx of candidateIndices) {
+            const stmtPath = bodyPaths[idx];
+            if (!stmtPath) continue;
+            stmtPath.traverse({
+              CallExpression(path) {
+                const node = path.node;
+                const parent = path.parent;
+                if (t.isMemberExpression(parent) && t.isCallExpression(path.parentPath.parent)) {
+                  chainCallPaths.set(node, path);
+                  return;
+                }
+                if (isMethodChainCandidate(node, fileKinds)) {
+                  candidatePaths.push(path);
+                }
+              }
+            });
+          }
+          programPath.stop();
+        }
+      });
+    } else {
+      babel.traverse(ast, {
+        CallExpression: (path) => {
+          const node = path.node;
+          const parent = path.parent;
+          if (t.isMemberExpression(parent) && t.isCallExpression(path.parentPath.parent)) {
+            chainCallPaths.set(node, path);
+            return;
+          }
+          if (isMethodChainCandidate(node, fileKinds)) {
             candidatePaths.push(path);
+            return;
+          }
+          if (checkDirectCalls) {
+            if (isTopLevelDirectCallCandidate(path)) {
+              candidatePaths.push(path);
+            } else if (isNestedDirectCallCandidate(node)) {
+              candidatePaths.push(path);
+            }
+          }
+        },
+        // Pattern 3: JSX element pattern (e.g., <ClientOnly>)
+        // Collect JSX elements where the component name matches a known import
+        // that resolves to a target component (e.g., ClientOnly from @tanstack/react-router)
+        JSXElement: (path) => {
+          if (!checkJSX || !jsxTargetComponentNames) return;
+          const openingElement = path.node.openingElement;
+          const nameNode = openingElement.name;
+          if (!t.isJSXIdentifier(nameNode)) return;
+          const componentName = nameNode.name;
+          const binding = moduleInfo.bindings.get(componentName);
+          if (!binding || binding.type !== "import") return;
+          if (jsxTargetComponentNames.has(binding.importedName)) {
+            jsxCandidatePaths.push(path);
           }
         }
-      }
-    });
-    if (candidatePaths.length === 0) {
+      });
+    }
+    if (candidatePaths.length === 0 && jsxCandidatePaths.length === 0) {
       return null;
     }
     const resolvedCandidates = await Promise.all(
@@ -312,7 +450,7 @@ class ServerFnCompiler {
     const validCandidates = resolvedCandidates.filter(
       ({ kind }) => this.validLookupKinds.has(kind)
     );
-    if (validCandidates.length === 0) {
+    if (validCandidates.length === 0 && jsxCandidatePaths.length === 0) {
       return null;
     }
     const pathsToRewrite = [];
@@ -380,6 +518,19 @@ class ServerFnCompiler {
         });
       }
     }
+    for (const jsxPath of jsxCandidatePaths) {
+      const openingElement = jsxPath.node.openingElement;
+      const nameNode = openingElement.name;
+      if (!t.isJSXIdentifier(nameNode)) continue;
+      const componentName = nameNode.name;
+      const binding = moduleInfo.bindings.get(componentName);
+      if (!binding || binding.type !== "import") continue;
+      const knownExports = this.knownRootImports.get(binding.source);
+      if (!knownExports) continue;
+      const kind = knownExports.get(binding.importedName);
+      if (kind !== "ClientOnlyJSX") continue;
+      handleClientOnlyJSX(jsxPath);
+    }
     deadCodeElimination(ast, refIdents);
     return generateFromAst(ast, {
       sourceMaps: true,
@@ -410,6 +561,16 @@ class ServerFnCompiler {
    * Returns the module info and binding if found, or undefined if not found.
    */
   async findExportInModule(moduleInfo, exportName, visitedModules = /* @__PURE__ */ new Set()) {
+    const isBuildMode = this.mode === "build";
+    if (isBuildMode && visitedModules.size === 0) {
+      const moduleCache = this.exportResolutionCache.get(moduleInfo.id);
+      if (moduleCache) {
+        const cached = moduleCache.get(exportName);
+        if (cached !== void 0) {
+          return cached ?? void 0;
+        }
+      }
+    }
     if (visitedModules.has(moduleInfo.id)) {
       return void 0;
     }
@@ -418,13 +579,17 @@ class ServerFnCompiler {
     if (directExport) {
       const binding = moduleInfo.bindings.get(directExport.name);
       if (binding) {
-        return { moduleInfo, binding };
+        const result = { moduleInfo, binding };
+        if (isBuildMode) {
+          this.getExportResolutionCache(moduleInfo.id).set(exportName, result);
+        }
+        return result;
       }
     }
     if (moduleInfo.reExportAllSources.length > 0) {
       const results = await Promise.all(
         moduleInfo.reExportAllSources.map(async (reExportSource) => {
-          const reExportTarget = await this.options.resolveId(
+          const reExportTarget = await this.resolveIdCached(
             reExportSource,
             moduleInfo.id
           );
@@ -441,10 +606,16 @@ class ServerFnCompiler {
       );
       for (const result of results) {
         if (result) {
+          if (isBuildMode) {
+            this.getExportResolutionCache(moduleInfo.id).set(exportName, result);
+          }
           return result;
         }
       }
     }
+    if (isBuildMode) {
+      this.getExportResolutionCache(moduleInfo.id).set(exportName, null);
+    }
     return void 0;
   }
   async resolveBindingKind(binding, fileId, visited = /* @__PURE__ */ new Set()) {
@@ -460,7 +631,7 @@ class ServerFnCompiler {
           return kind;
         }
       }
-      const target = await this.options.resolveId(binding.source, fileId);
+      const target = await this.resolveIdCached(binding.source, fileId);
       if (!target) {
         return "None";
       }
@@ -553,7 +724,7 @@ class ServerFnCompiler {
         const info = await this.getModuleInfo(fileId);
         const binding = info.bindings.get(callee.object.name);
         if (binding && binding.type === "import" && binding.importedName === "*") {
-          const targetModuleId = await this.options.resolveId(
+          const targetModuleId = await this.resolveIdCached(
             binding.source,
             fileId
           );