@tanstack/start-plugin-core 1.167.17 → 1.167.19

package/src/start-compiler/server-fn-resolver-module.ts

@@ -0,0 +1,129 @@
+import type { ServerFn } from './types'
+
+interface ResolverManifestEntry {
+  id: string
+  functionName: string
+  extractedFilename: string
+  isClientReferenced: boolean
+}
+
+interface GenerateServerFnResolverModuleOptions {
+  serverFnsById: Record<string, ServerFn>
+  includeClientReferencedCheck: boolean
+  useStaticImports?: boolean
+}
+
+function getResolverManifestEntries(
+  serverFnsById: Record<string, ServerFn>,
+): Array<ResolverManifestEntry> {
+  return Object.entries(serverFnsById).map(([id, fn]) => ({
+    id,
+    functionName: fn.functionName,
+    extractedFilename: fn.extractedFilename,
+    isClientReferenced: fn.isClientReferenced ?? true,
+  }))
+}
+
+function getClientReferencedCheck(
+  includeClientReferencedCheck: boolean,
+): string {
+  if (!includeClientReferencedCheck) {
+    return ''
+  }
+
+  return `
+  if (access.origin === 'client' && !serverFnInfo.isClientReferenced) {
+    throw new Error('Server function not accessible from client: ' + id)
+  }
+`
+}
+
+function getResolverBody(): string {
+  return `
+export async function getServerFnById(id, access) {
+  const serverFnInfo = manifest[id]
+  if (!serverFnInfo) {
+    throw new Error('Server function info not found for ' + id)
+  }
+__CLIENT_REFERENCED_CHECK__
+  const fnModule = serverFnInfo.module ?? (await serverFnInfo.importer())
+  if (!fnModule) {
+    throw new Error('Server function module not resolved for ' + id)
+  }
+  const action = fnModule[serverFnInfo.functionName]
+  if (!action) {
+    throw new Error('Server function module export not resolved for serverFn ID: ' + id)
+  }
+  return action
+}
+`
+}
+
+function getResolverManifestModuleAccess(opts: {
+  useStaticImports?: boolean
+  extractedFilename: string
+  moduleRef: string
+}): string {
+  if (opts.useStaticImports) {
+    return `module: ${opts.moduleRef}`
+  }
+
+  return `importer: () => import(${JSON.stringify(opts.extractedFilename)})`
+}
+
+function getResolverManifestEntry(opts: {
+  entry: ResolverManifestEntry
+  moduleAccess: string
+  includeClientReferencedCheck: boolean
+}): string {
+  const clientReferenced = opts.includeClientReferencedCheck
+    ? `,\n    isClientReferenced: ${opts.entry.isClientReferenced}`
+    : ''
+
+  return `'${opts.entry.id}': {
+    functionName: '${opts.entry.functionName}',
+    ${opts.moduleAccess}${clientReferenced}
+  }`
+}
+
+export function generateServerFnResolverModule(
+  opts: GenerateServerFnResolverModuleOptions,
+): string {
+  const manifestEntries = getResolverManifestEntries(opts.serverFnsById)
+  const staticImports: Array<string> = []
+
+  const manifest = manifestEntries
+    .map((entry, index) => {
+      const moduleRef = `serverFnModule${index}`
+
+      if (opts.useStaticImports) {
+        staticImports.push(
+          `import * as ${moduleRef} from ${JSON.stringify(entry.extractedFilename)}`,
+        )
+      }
+
+      return getResolverManifestEntry({
+        entry,
+        moduleAccess: getResolverManifestModuleAccess({
+          useStaticImports: opts.useStaticImports,
+          extractedFilename: entry.extractedFilename,
+          moduleRef,
+        }),
+        includeClientReferencedCheck: opts.includeClientReferencedCheck,
+      })
+    })
+    .join(',\n  ')
+
+  const body = getResolverBody().replace(
+    '__CLIENT_REFERENCED_CHECK__',
+    getClientReferencedCheck(opts.includeClientReferencedCheck),
+  )
+
+  return `
+${staticImports.join('\n')}
+const manifest = {
+  ${manifest}
+}
+${body}
+`
+}

package/src/{start-compiler-plugin → start-compiler}/types.ts

@@ -112,6 +112,11 @@ export type GenerateFunctionIdFnOptional = (
  * Function type for generating replacement code for server functions.
  * Used internally by handleCreateServerFn.
  */
+export type DevServerFnModuleSpecifierEncoder = (opts: {
+  extractedFilename: string
+  root: string
+}) => string
+
 export type ReplacerFn = (opts: {
   /** Placeholder for the original function expression */
   fn: string

package/src/start-manifest-plugin/manifestBuilder.ts

@@ -1,9 +1,13 @@
 /* eslint-disable @typescript-eslint/prefer-for-of */
 import { joinURL } from 'ufo'
 import { resolveManifestAssetLink, rootRouteId } from '@tanstack/router-core'
-import { tsrSplit } from '@tanstack/router-plugin'
+import {
+  getRouteFilePathsFromModuleIds,
+  normalizeViteClientBuild,
+  normalizeViteClientChunk,
+} from '../vite/start-manifest-plugin/normalized-client-build'
 import type { ManifestAssetLink, RouterManagedTag } from '@tanstack/router-core'
-import type { Rollup } from 'vite'
+import type { NormalizedClientBuild, NormalizedClientChunk } from '../types'
 
 const ROUTER_MANAGED_MODE = 1
 const NON_ROUTE_DYNAMIC_MODE = 2
@@ -19,15 +23,15 @@ type RouteTreeRoute = {
 type RouteTreeRoutes = Record<string, RouteTreeRoute>
 
 interface ScannedClientChunks {
-  entryChunk: Rollup.OutputChunk
-  chunksByFileName: Map<string, Rollup.OutputChunk>
-  routeChunksByFilePath: Map<string, Array<Rollup.OutputChunk>>
-  routeEntryChunks: Set<Rollup.OutputChunk>
+  entryChunk: NormalizedClientChunk
+  chunksByFileName: ReadonlyMap<string, NormalizedClientChunk>
+  routeChunksByFilePath: ReadonlyMap<string, Array<NormalizedClientChunk>>
+  routeEntryChunks: ReadonlySet<NormalizedClientChunk>
 }
 
 interface ManifestAssetResolvers {
   getAssetPath: (fileName: string) => string
-  getChunkPreloads: (chunk: Rollup.OutputChunk) => Array<string>
+  getChunkPreloads: (chunk: NormalizedClientChunk) => Array<string>
   getStylesheetAsset: (cssFile: string) => RouterManagedTag
 }
 
@@ -121,9 +125,9 @@ function getAssetIdentity(asset: RouterManagedTag) {
 
 function mergeRouteChunkData(options: {
   route: RouteTreeRoute
-  chunk: Rollup.OutputChunk
-  getChunkCssAssets: (chunk: Rollup.OutputChunk) => Array<RouterManagedTag>
-  getChunkPreloads: (chunk: Rollup.OutputChunk) => Array<string>
+  chunk: NormalizedClientChunk
+  getChunkCssAssets: (chunk: NormalizedClientChunk) => Array<RouterManagedTag>
+  getChunkPreloads: (chunk: NormalizedClientChunk) => Array<string>
 }) {
   const chunkAssets = options.getChunkCssAssets(options.chunk)
   const chunkPreloads = options.getChunkPreloads(options.chunk)
@@ -136,11 +140,11 @@ function mergeRouteChunkData(options: {
 }
 
 export function buildStartManifest(options: {
-  clientBundle: Rollup.OutputBundle
+  clientBuild: NormalizedClientBuild
   routeTreeRoutes: RouteTreeRoutes
   basePath: string
 }) {
-  const scannedChunks = scanClientChunks(options.clientBundle)
+  const scannedChunks = scanClientChunks(options.clientBuild)
   const hashedCssFiles = collectDynamicImportCss(
     scannedChunks.routeEntryChunks,
     scannedChunks.chunksByFileName,
@@ -178,110 +182,52 @@ export function buildStartManifest(options: {
 }
 
 export function scanClientChunks(
-  clientBundle: Rollup.OutputBundle,
+  clientBuild: NormalizedClientBuild,
 ): ScannedClientChunks {
-  let entryChunk: Rollup.OutputChunk | undefined
-  const chunksByFileName = new Map<string, Rollup.OutputChunk>()
-  const routeChunksByFilePath = new Map<string, Array<Rollup.OutputChunk>>()
-  const routeEntryChunks = new Set<Rollup.OutputChunk>()
-
-  for (const fileName in clientBundle) {
-    const bundleEntry = clientBundle[fileName]!
-    if (bundleEntry.type !== 'chunk') {
-      continue
-    }
-
-    chunksByFileName.set(bundleEntry.fileName, bundleEntry)
+  const entryChunk = clientBuild.chunksByFileName.get(
+    clientBuild.entryChunkFileName,
+  )
 
-    if (bundleEntry.isEntry) {
-      if (entryChunk) {
-        throw new Error(
-          `multiple entries detected: ${entryChunk.fileName} ${bundleEntry.fileName}`,
-        )
-      }
-      entryChunk = bundleEntry
-    }
+  if (!entryChunk) {
+    throw new Error(`Missing entry chunk: ${clientBuild.entryChunkFileName}`)
+  }
 
-    const routeFilePaths = getRouteFilePathsFromModuleIds(bundleEntry.moduleIds)
-    if (routeFilePaths.length === 0) {
-      continue
-    }
+  const routeEntryChunks = new Set<NormalizedClientChunk>()
+  const routeChunksByFilePath = new Map<string, Array<NormalizedClientChunk>>()
 
-    routeEntryChunks.add(bundleEntry)
+  for (const chunk of clientBuild.chunksByFileName.values()) {
+    if (chunk.routeFilePaths.length > 0) {
+      routeEntryChunks.add(chunk)
 
-    for (let i = 0; i < routeFilePaths.length; i++) {
-      const routeFilePath = routeFilePaths[i]!
-      let chunks = routeChunksByFilePath.get(routeFilePath)
-      if (chunks === undefined) {
-        chunks = []
-        routeChunksByFilePath.set(routeFilePath, chunks)
+      for (const routeFilePath of chunk.routeFilePaths) {
+        let chunks = routeChunksByFilePath.get(routeFilePath)
+        if (chunks === undefined) {
+          chunks = []
+          routeChunksByFilePath.set(routeFilePath, chunks)
+        }
+        chunks.push(chunk)
       }
-      chunks.push(bundleEntry)
     }
   }
 
-  if (!entryChunk) {
-    throw new Error('No entry file found')
-  }
-
   return {
     entryChunk,
-    chunksByFileName,
+    chunksByFileName: clientBuild.chunksByFileName,
     routeChunksByFilePath,
     routeEntryChunks,
   }
 }
 
-export function getRouteFilePathsFromModuleIds(moduleIds: Array<string>) {
-  let routeFilePaths: Array<string> | undefined
-  let seenRouteFilePaths: Set<string> | undefined
-
-  for (const moduleId of moduleIds) {
-    const queryIndex = moduleId.indexOf('?')
-
-    if (queryIndex < 0) {
-      continue
-    }
-
-    const query = moduleId.slice(queryIndex + 1)
-
-    // Fast check before allocating URLSearchParams
-    if (!query.includes(tsrSplit)) {
-      continue
-    }
-
-    if (!new URLSearchParams(query).has(tsrSplit)) {
-      continue
-    }
-
-    const routeFilePath = moduleId.slice(0, queryIndex)
-
-    if (seenRouteFilePaths?.has(routeFilePath)) {
-      continue
-    }
-
-    if (routeFilePaths === undefined) {
-      routeFilePaths = []
-      seenRouteFilePaths = new Set<string>()
-    }
-
-    routeFilePaths.push(routeFilePath)
-    seenRouteFilePaths!.add(routeFilePath)
-  }
-
-  return routeFilePaths ?? []
-}
-
 export function collectDynamicImportCss(
-  routeEntryChunks: Set<Rollup.OutputChunk>,
-  chunksByFileName: Map<string, Rollup.OutputChunk>,
-  entryChunk?: Rollup.OutputChunk,
+  routeEntryChunks: ReadonlySet<NormalizedClientChunk>,
+  chunksByFileName: ReadonlyMap<string, NormalizedClientChunk>,
+  entryChunk?: NormalizedClientChunk,
 ) {
   const routerManagedCssFiles = new Set<string>()
   const nonRouteDynamicCssFiles = new Set<string>()
   const hashedCssFiles = new Set<string>()
-  const visitedByChunk = new Map<Rollup.OutputChunk, number>()
-  const chunkStack: Array<Rollup.OutputChunk> = []
+  const visitedByChunk = new Map<NormalizedClientChunk, number>()
+  const chunkStack: Array<NormalizedClientChunk> = []
   const modeStack: Array<number> = []
 
   for (const routeEntryChunk of routeEntryChunks) {
@@ -306,13 +252,13 @@ export function collectDynamicImportCss(
     visitedByChunk.set(chunk, previousMode | mode)
 
     if ((mode & ROUTER_MANAGED_MODE) !== 0) {
-      for (const cssFile of chunk.viteMetadata?.importedCss ?? []) {
+      for (const cssFile of chunk.css) {
         routerManagedCssFiles.add(cssFile)
       }
     }
 
     if ((mode & NON_ROUTE_DYNAMIC_MODE) !== 0) {
-      for (const cssFile of chunk.viteMetadata?.importedCss ?? []) {
+      for (const cssFile of chunk.css) {
         nonRouteDynamicCssFiles.add(cssFile)
       }
     }
@@ -356,7 +302,7 @@ export function createManifestAssetResolvers(options: {
 }): ManifestAssetResolvers {
   const assetPathByFileName = new Map<string, string>()
   const stylesheetAssetByFileName = new Map<string, RouterManagedTag>()
-  const preloadsByChunk = new Map<Rollup.OutputChunk, Array<string>>()
+  const preloadsByChunk = new Map<NormalizedClientChunk, Array<string>>()
 
   const getAssetPath = (fileName: string) => {
     const cachedPath = assetPathByFileName.get(fileName)
@@ -389,7 +335,7 @@ export function createManifestAssetResolvers(options: {
     return asset
   }
 
-  const getChunkPreloads = (chunk: Rollup.OutputChunk) => {
+  const getChunkPreloads = (chunk: NormalizedClientChunk) => {
     const cachedPreloads = preloadsByChunk.get(chunk)
     if (cachedPreloads) {
       return cachedPreloads
@@ -413,11 +359,14 @@ export function createManifestAssetResolvers(options: {
 }
 
 export function createChunkCssAssetCollector(options: {
-  chunksByFileName: Map<string, Rollup.OutputChunk>
+  chunksByFileName: ReadonlyMap<string, NormalizedClientChunk>
   getStylesheetAsset: (cssFile: string) => RouterManagedTag
 }) {
-  const assetsByChunk = new Map<Rollup.OutputChunk, Array<RouterManagedTag>>()
-  const stateByChunk = new Map<Rollup.OutputChunk, number>()
+  const assetsByChunk = new Map<
+    NormalizedClientChunk,
+    Array<RouterManagedTag>
+  >()
+  const stateByChunk = new Map<NormalizedClientChunk, number>()
 
   const appendAsset = (
     assets: Array<RouterManagedTag>,
@@ -434,7 +383,7 @@ export function createChunkCssAssetCollector(options: {
   }
 
   const getChunkCssAssets = (
-    chunk: Rollup.OutputChunk,
+    chunk: NormalizedClientChunk,
   ): Array<RouterManagedTag> => {
     const cachedAssets = assetsByChunk.get(chunk)
     if (cachedAssets) {
@@ -449,7 +398,7 @@ export function createChunkCssAssetCollector(options: {
     const assets: Array<RouterManagedTag> = []
     const seenAssets = new Set<string>()
 
-    for (const cssFile of chunk.viteMetadata?.importedCss ?? []) {
+    for (const cssFile of chunk.css) {
       appendAsset(assets, seenAssets, options.getStylesheetAsset(cssFile))
     }
 
@@ -475,9 +424,12 @@ export function createChunkCssAssetCollector(options: {
 
 export function buildRouteManifestRoutes(options: {
   routeTreeRoutes: RouteTreeRoutes
-  routeChunksByFilePath: Map<string, Array<Rollup.OutputChunk>>
-  chunksByFileName: Map<string, Rollup.OutputChunk>
-  entryChunk: Rollup.OutputChunk
+  routeChunksByFilePath: ReadonlyMap<
+    string,
+    ReadonlyArray<NormalizedClientChunk>
+  >
+  chunksByFileName: ReadonlyMap<string, NormalizedClientChunk>
+  entryChunk: NormalizedClientChunk
   assetResolvers: ManifestAssetResolvers
 }) {
   const routes: Record<string, RouteTreeRoute> = {}
@@ -526,6 +478,12 @@ export function buildRouteManifestRoutes(options: {
   return routes
 }
 
+export {
+  getRouteFilePathsFromModuleIds,
+  normalizeViteClientBuild,
+  normalizeViteClientChunk,
+}
+
 function dedupeNestedRouteManifestEntries(
   routeId: string,
   route: DedupeRoute,

package/src/start-router-plugin/route-tree-footer.ts

@@ -0,0 +1,99 @@
+import path from 'pathe'
+import type { GetConfigFn, TanStackStartCoreOptions } from '../types'
+
+function buildRouteTreeFileFooter(opts: {
+  generatedRouteTreePath: string
+  startFilePath: string | undefined
+  routerFilePath: string
+  framework: TanStackStartCoreOptions['framework']
+  userFooter?: Array<string> | (() => Array<string>)
+}): Array<string> {
+  function getImportPath(absolutePath: string) {
+    let relativePath = path.relative(
+      path.dirname(opts.generatedRouteTreePath),
+      absolutePath,
+    )
+
+    if (!relativePath.startsWith('.')) {
+      relativePath = './' + relativePath
+    }
+
+    return relativePath.split(path.sep).join('/')
+  }
+
+  function appendFooterBlock(lines: Array<string>, block: string) {
+    if (!block) {
+      return
+    }
+
+    if (lines.length > 0) {
+      lines[lines.length - 1] += `\n${block}`
+      return
+    }
+
+    lines.push(block)
+  }
+
+  const footer: Array<string> = []
+
+  appendFooterBlock(
+    footer,
+    `import type { getRouter } from '${getImportPath(opts.routerFilePath)}'`,
+  )
+
+  if (opts.startFilePath) {
+    appendFooterBlock(
+      footer,
+      `import type { startInstance } from '${getImportPath(opts.startFilePath)}'`,
+    )
+  } else {
+    appendFooterBlock(
+      footer,
+      `import type { createStart } from '@tanstack/${opts.framework}-start'`,
+    )
+  }
+
+  appendFooterBlock(
+    footer,
+    `declare module '@tanstack/${opts.framework}-start' {
+  interface Register {
+    ssr: true
+    router: Awaited<ReturnType<typeof getRouter>>`,
+  )
+
+  if (opts.startFilePath) {
+    appendFooterBlock(
+      footer,
+      `    config: Awaited<ReturnType<typeof startInstance.getOptions>>`,
+    )
+  }
+
+  appendFooterBlock(
+    footer,
+    `  }
+}`,
+  )
+
+  if (opts.userFooter) {
+    footer.push(
+      ...(Array.isArray(opts.userFooter) ? opts.userFooter : opts.userFooter()),
+    )
+  }
+
+  return footer
+}
+
+export function buildRouteTreeFileFooterFromConfig(opts: {
+  generatedRouteTreePath: string
+  getConfig: GetConfigFn
+  corePluginOpts: TanStackStartCoreOptions
+}): Array<string> {
+  const { startConfig, resolvedStartConfig } = opts.getConfig()
+  return buildRouteTreeFileFooter({
+    generatedRouteTreePath: opts.generatedRouteTreePath,
+    startFilePath: resolvedStartConfig.startFilePath,
+    routerFilePath: resolvedStartConfig.routerFilePath,
+    framework: opts.corePluginOpts.framework,
+    userFooter: startConfig.router.routeTreeFileFooter,
+  })
+}

package/src/types.ts

@@ -2,19 +2,63 @@ import type { TanStackStartOutputConfig } from './schema'
 
 export type CompileStartFrameworkOptions = 'react' | 'solid' | 'vue'
 
-export interface TanStackStartVitePluginCoreOptions {
+export type ServerFnLookupAccess = { origin: 'client' } | { origin: 'server' }
+
+export type SerializationRuntime = 'client' | 'server'
+
+export interface SerializationAdapterModuleRef {
+  module: string
+  export: string
+  isFactory?: boolean
+}
+
+export type SerializationAdapterByRuntime = Partial<
+  Record<SerializationRuntime, SerializationAdapterModuleRef>
+>
+
+export type SerializationAdapterConfig =
+  | SerializationAdapterModuleRef
+  | SerializationAdapterByRuntime
+
+export interface NormalizedBasePaths {
+  publicBase: string
+  assetBase: {
+    dev: string
+    build: string
+  }
+}
+
+export interface NormalizedOutputDirectories {
+  client: string
+  server: string
+}
+
+export interface NormalizedClientChunk {
+  fileName: string
+  isEntry: boolean
+  imports: Array<string>
+  dynamicImports: Array<string>
+  css: Array<string>
+  routeFilePaths: Array<string>
+}
+
+export interface NormalizedClientBuild {
+  entryChunkFileName: string
+  chunksByFileName: ReadonlyMap<string, NormalizedClientChunk>
+  chunkFileNamesByRouteFilePath: ReadonlyMap<string, ReadonlyArray<string>>
+  cssFilesBySourcePath: ReadonlyMap<string, ReadonlyArray<string>>
+}
+
+export interface TanStackStartCoreOptions {
   framework: CompileStartFrameworkOptions
   defaultEntryPaths: {
     client: string
     server: string
     start: string
   }
-  serverFn?: {
-    ssr?: {
-      getServerFnById?: string
-    }
-    providerEnv?: string
-  }
+  providerEnvironmentName: string
+  ssrIsProvider: boolean
+  serializationAdapters?: Array<SerializationAdapterConfig> | undefined
 }
 
 export interface ResolvedStartConfig {
@@ -22,12 +66,11 @@ export interface ResolvedStartConfig {
   startFilePath: string | undefined
   routerFilePath: string
   srcDirectory: string
-  viteAppBase: string
-  serverFnProviderEnv: string
+  basePaths: NormalizedBasePaths
+  outputDirectories: NormalizedOutputDirectories
 }
 
 export type GetConfigFn = () => {
   startConfig: TanStackStartOutputConfig
   resolvedStartConfig: ResolvedStartConfig
-  corePluginOpts: TanStackStartVitePluginCoreOptions
 }

package/src/{dev-server-plugin → vite/dev-server-plugin}/plugin.ts

@@ -1,8 +1,8 @@
 import { isRunnableDevEnvironment } from 'vite'
 import { VIRTUAL_MODULES } from '@tanstack/start-server-core'
 import { NodeRequest, sendNodeResponse } from 'srvx/node'
-import { ENTRY_POINTS, VITE_ENVIRONMENT_NAMES } from '../constants'
-import { resolveViteId } from '../utils'
+import { ENTRY_POINTS, VITE_ENVIRONMENT_NAMES } from '../../constants'
+import { resolveViteId } from '../../utils'
 import { extractHtmlScripts } from './extract-html-scripts'
 import {
   CSS_MODULES_REGEX,
@@ -10,14 +10,16 @@ import {
   normalizeCssModuleCacheKey,
 } from './dev-styles'
 import type { Connect, DevEnvironment, PluginOption } from 'vite'
-import type { GetConfigFn } from '../types'
+import type { GetConfigFn } from '../../types'
 
 export function devServerPlugin({
-  getConfig,
+  getConfig: _getConfig,
   devSsrStylesEnabled,
+  installDevServerMiddleware,
 }: {
   getConfig: GetConfigFn
   devSsrStylesEnabled: boolean
+  installDevServerMiddleware: boolean | undefined
 }): PluginOption {
   let isTest = false
 
@@ -132,8 +134,7 @@ export function devServerPlugin({
             )
           }
 
-          const { startConfig } = getConfig()
-          const installMiddleware = startConfig.vite?.installDevServerMiddleware
+          const installMiddleware = installDevServerMiddleware
           if (installMiddleware === false) {
             return
           }

package/src/{output-directory.ts → vite/output-directory.ts}

@@ -1,6 +1,6 @@
 import { join } from 'pathe'
-import { VITE_ENVIRONMENT_NAMES } from './constants'
-import type { ViteEnvironmentNames } from './constants'
+import { VITE_ENVIRONMENT_NAMES } from '../constants'
+import type { ViteEnvironmentNames } from '../constants'
 import type * as vite from 'vite'
 
 export function getClientOutputDirectory(