@tanstack/start-plugin-core 1.132.0-alpha.9 → 1.132.0

package/src/plugin.ts

@@ -20,7 +20,10 @@ import {
 import { postServerBuild } from './post-server-build'
 import { createServerFnPlugin } from './create-server-fn-plugin/plugin'
 import type { ViteEnvironmentNames } from './constants'
-import type { TanStackStartInputConfig } from './schema'
+import type {
+  TanStackStartInputConfig,
+  TanStackStartOutputConfig,
+} from './schema'
 import type { PluginOption } from 'vite'
 import type { CompileStartFrameworkOptions } from './start-compiler-plugin/compilers'
 
@@ -29,19 +32,46 @@ export interface TanStackStartVitePluginCoreOptions {
   defaultEntryPaths: {
     client: string
     server: string
+    start: string
   }
-  crawlPackages?: (opts: {
-    name: string
-    peerDependencies: Record<string, any>
-    exports?: Record<string, any> | string
-  }) => 'include' | 'exclude' | undefined
 }
 
+export interface ResolvedStartConfig {
+  root: string
+  startFilePath: string | undefined
+  routerFilePath: string
+  srcDirectory: string
+}
+
+export type GetConfigFn = () => {
+  startConfig: TanStackStartOutputConfig
+  resolvedStartConfig: ResolvedStartConfig
+}
 export function TanStackStartVitePluginCore(
   corePluginOpts: TanStackStartVitePluginCoreOptions,
   startPluginOpts: TanStackStartInputConfig,
 ): Array<PluginOption> {
-  const startConfig = parseStartConfig(startPluginOpts)
+  const resolvedStartConfig: ResolvedStartConfig = {
+    root: '',
+    startFilePath: undefined,
+    routerFilePath: '',
+    srcDirectory: '',
+  }
+
+  let startConfig: TanStackStartOutputConfig | null
+  const getConfig: GetConfigFn = () => {
+    if (!resolvedStartConfig.root) {
+      throw new Error(`Cannot get config before root is resolved`)
+    }
+    if (!startConfig) {
+      startConfig = parseStartConfig(
+        startPluginOpts,
+        corePluginOpts,
+        resolvedStartConfig.root,
+      )
+    }
+    return { startConfig, resolvedStartConfig }
+  }
 
   const capturedBundle: Partial<
     Record<ViteEnvironmentNames, vite.Rollup.OutputBundle>
@@ -56,33 +86,42 @@ export function TanStackStartVitePluginCore(
   }
 
   return [
-    tanStackStartRouter({
-      ...startConfig.router,
-      target: corePluginOpts.framework,
-      autoCodeSplitting: true,
-    }),
     {
       name: 'tanstack-start-core:config',
+      enforce: 'pre',
       async config(viteConfig, { command }) {
         const viteAppBase = trimPathRight(viteConfig.base || '/')
         globalThis.TSS_APP_BASE = viteAppBase
 
         const root = viteConfig.root || process.cwd()
+        resolvedStartConfig.root = root
+
+        const { startConfig } = getConfig()
         const resolvedSrcDirectory = join(root, startConfig.srcDirectory)
+        resolvedStartConfig.srcDirectory = resolvedSrcDirectory
+
+        const startFilePath = resolveEntry({
+          type: 'start entry',
+          configuredEntry: startConfig.start.entry,
+          defaultEntry: 'start',
+          resolvedSrcDirectory,
+          required: false,
+        })
+        resolvedStartConfig.startFilePath = startFilePath
 
         const routerFilePath = resolveEntry({
           type: 'router entry',
           configuredEntry: startConfig.router.entry,
           defaultEntry: 'router',
-          root,
           resolvedSrcDirectory,
           required: true,
         })
+        resolvedStartConfig.routerFilePath = routerFilePath
+
         const clientEntryPath = resolveEntry({
           type: 'client entry',
           configuredEntry: startConfig.client.entry,
           defaultEntry: 'client',
-          root,
           resolvedSrcDirectory,
           required: false,
         })
@@ -91,7 +130,6 @@ export function TanStackStartVitePluginCore(
           type: 'server entry',
           configuredEntry: startConfig.server.entry,
           defaultEntry: 'server',
-          root,
           resolvedSrcDirectory,
           required: false,
         })
@@ -104,42 +142,33 @@ export function TanStackStartVitePluginCore(
         } else {
           clientAlias = corePluginOpts.defaultEntryPaths.client
         }
+
         let serverAlias: string
         if (serverEntryPath) {
           serverAlias = vite.normalizePath(path.resolve(root, serverEntryPath))
         } else {
           serverAlias = corePluginOpts.defaultEntryPaths.server
         }
+
+        let startAlias: string
+        if (startFilePath) {
+          startAlias = vite.normalizePath(path.resolve(root, startFilePath))
+        } else {
+          startAlias = corePluginOpts.defaultEntryPaths.start
+        }
+
         const entryAliasConfiguration: Record<
           (typeof ENTRY_POINTS)[keyof typeof ENTRY_POINTS],
           string
         > = {
+          [ENTRY_POINTS.start]: startAlias,
           [ENTRY_POINTS.router]: routerFilePath,
           [ENTRY_POINTS.client]: clientAlias,
           [ENTRY_POINTS.server]: serverAlias,
         }
 
-        // TODO
-        /* const nitroOutputPublicDir = await (async () => {
-          // Create a dummy nitro app to get the resolved public output path
-          const dummyNitroApp = await createNitro({
-            preset: startConfig.target,
-            compatibilityDate: '2024-12-01',
-          })
-
-          const nitroOutputPublicDir = dummyNitroApp.options.output.publicDir
-          await dummyNitroApp.close()
-
-          return nitroOutputPublicDir
-        })()*/
-
-        const startPackageName = `@tanstack/${corePluginOpts.framework}-start`
-        const routerPackageName = `@tanstack/${corePluginOpts.framework}-router`
-
-        const additionalOptimizeDeps = {
-          include: new Set<string>(),
-          exclude: new Set<string>(),
-        }
+        const startPackageName =
+          `@tanstack/${corePluginOpts.framework}-start` as const
 
         // crawl packages that have start in "peerDependencies"
         // see https://github.com/svitejs/vitefu/blob/d8d82fa121e3b2215ba437107093c77bde51b63b/src/index.js#L95-L101
@@ -147,34 +176,16 @@ export function TanStackStartVitePluginCore(
         // this is currently uncached; could be implemented similarly as vite handles lock file changes
         // see https://github.com/vitejs/vite/blob/557f797d29422027e8c451ca50dd84bf8c41b5f0/packages/vite/src/node/optimizer/index.ts#L1282
 
-        const result = await crawlFrameworkPkgs({
+        const crawlFrameworkPkgsResult = await crawlFrameworkPkgs({
           root: process.cwd(),
           isBuild: command === 'build',
           isFrameworkPkgByJson(pkgJson) {
-            if ([routerPackageName, startPackageName].includes(pkgJson.name)) {
-              return false
-            }
-
             const peerDependencies = pkgJson['peerDependencies']
 
             if (peerDependencies) {
-              const internalResult = corePluginOpts.crawlPackages?.({
-                name: pkgJson.name,
-                peerDependencies,
-                exports: pkgJson.exports,
-              })
-              if (internalResult) {
-                if (internalResult === 'exclude') {
-                  additionalOptimizeDeps.exclude.add(pkgJson.name)
-                } else {
-                  additionalOptimizeDeps.include.add(pkgJson.name)
-                }
-              }
-              return (
-                startPackageName in peerDependencies ||
-                routerPackageName in peerDependencies
-              )
+              return startPackageName in peerDependencies
             }
+
             return false
           },
         })
@@ -198,6 +209,7 @@ export function TanStackStartVitePluginCore(
             },
             [VITE_ENVIRONMENT_NAMES.server]: {
               consumer: 'server',
+
               build: {
                 ssr: true,
                 rollupOptions: {
@@ -213,42 +225,20 @@ export function TanStackStartVitePluginCore(
                   viteConfig.environments?.[VITE_ENVIRONMENT_NAMES.server]
                     ?.build?.copyPublicDir ?? false,
               },
-              optimizeDeps: {
-                exclude: [
-                  ...Object.values(VIRTUAL_MODULES),
-                  ...result.optimizeDeps.exclude.sort(),
-                  ...additionalOptimizeDeps.exclude,
-                  `@tanstack/${corePluginOpts.framework}-start/server`,
-                ],
-                include: [
-                  ...additionalOptimizeDeps.include,
-                  ...result.optimizeDeps.include.sort(),
-                ],
-              },
             },
           },
+
           resolve: {
             noExternal: [
+              // ENTRY_POINTS.start,
               '@tanstack/start**',
               `@tanstack/${corePluginOpts.framework}-start**`,
-              ...Object.values(VIRTUAL_MODULES),
-              startPackageName,
-              ...result.ssr.noExternal.sort(),
+              ...crawlFrameworkPkgsResult.ssr.noExternal.sort(),
             ],
-            dedupe: [startPackageName],
             alias: {
               ...entryAliasConfiguration,
             },
           },
-          optimizeDeps: {
-            exclude: [
-              ...Object.values(VIRTUAL_MODULES),
-              startPackageName,
-              ...result.optimizeDeps.exclude.sort(),
-              ...additionalOptimizeDeps.exclude,
-            ],
-            include: [...additionalOptimizeDeps.include],
-          },
           /* prettier-ignore */
           define: {
             // define is an esbuild function that replaces the any instances of given keys with the given values
@@ -290,9 +280,11 @@ export function TanStackStartVitePluginCore(
         }
       },
     },
-    createServerFnPlugin(corePluginOpts.framework),
+    tanStackStartRouter(startPluginOpts, getConfig, corePluginOpts),
     // N.B. TanStackStartCompilerPlugin must be before the TanStackServerFnPluginEnv
     startCompilerPlugin(corePluginOpts.framework),
+    createServerFnPlugin(corePluginOpts.framework),
+
     TanStackServerFnPluginEnv({
       // This is the ID that will be available to look up and import
       // our server function manifest and resolve its module
@@ -314,7 +306,7 @@ export function TanStackStartVitePluginCore(
     startManifestPlugin({
       getClientBundle: () => getBundle(VITE_ENVIRONMENT_NAMES.client),
     }),
-    devServerPlugin({ startConfig }),
+    devServerPlugin({ getConfig }),
     {
       name: 'tanstack-start:core:capture-bundle',
       applyToEnvironment(e) {

package/src/resolve-entries.ts

@@ -24,7 +24,6 @@ export function resolveEntry<
   configuredEntry?: string
   defaultEntry: string
   resolvedSrcDirectory: string
-  root: string
   required: TRequired
 }): TReturn {
   let resolveOptions: ResolveModuleOptions
@@ -38,7 +37,7 @@ export function resolveEntry<
   } else {
     resolveOptions = {
       baseName: opts.configuredEntry,
-      from: opts.root,
+      from: opts.resolvedSrcDirectory,
     }
   }
 

package/src/schema.ts

@@ -1,32 +1,44 @@
 import path from 'node:path'
 import { z } from 'zod'
-import { configSchema, getConfig } from '@tanstack/router-generator'
+import { configSchema, getConfig } from '@tanstack/router-plugin'
+import type { TanStackStartVitePluginCoreOptions } from './plugin'
 
-const tsrConfig = configSchema.omit({ autoCodeSplitting: true }).partial()
+const tsrConfig = configSchema
+  .omit({ autoCodeSplitting: true, target: true, verboseFileRoutes: true })
+  .partial()
 
 export function parseStartConfig(
-  opts?: z.input<typeof tanstackStartOptionsSchema>,
+  opts: z.input<typeof tanstackStartOptionsSchema>,
+  corePluginOpts: TanStackStartVitePluginCoreOptions,
+  root: string,
 ) {
   const options = tanstackStartOptionsSchema.parse(opts)
 
   const srcDirectory = options.srcDirectory
 
-  const routesDirectory =
-    options.router.routesDirectory ?? path.join(srcDirectory, 'routes')
+  const routesDirectory = path.resolve(
+    srcDirectory,
+    options.router.routesDirectory ?? 'routes',
+  )
 
-  const generatedRouteTree =
-    options.router.generatedRouteTree ??
-    path.join(srcDirectory, 'routeTree.gen.ts')
+  const generatedRouteTree = path.resolve(
+    srcDirectory,
+    options.router.generatedRouteTree ?? 'routeTree.gen.ts',
+  )
 
   return {
     ...options,
     router: {
       ...options.router,
-      ...getConfig({
-        ...options.router,
-        routesDirectory,
-        generatedRouteTree,
-      }),
+      ...getConfig(
+        {
+          ...options.router,
+          routesDirectory,
+          generatedRouteTree,
+        },
+        root,
+      ),
+      target: corePluginOpts.framework,
     },
   }
 }
@@ -115,9 +127,14 @@ const pageSchema = pageBaseSchema.extend({
 const tanstackStartOptionsSchema = z
   .object({
     srcDirectory: z.string().optional().default('src'),
+    start: z
+      .object({
+        entry: z.string().optional(),
+      })
+      .optional()
+      .default({}),
     router: z
       .object({
-        // TODO this will move to 'start' once we have `createStart`
         entry: z.string().optional(),
       })
       .and(tsrConfig.optional().default({}))

package/src/start-compiler-plugin/compilers.ts

@@ -7,9 +7,7 @@ import {
 } from 'babel-dead-code-elimination'
 import { generateFromAst, parseAst } from '@tanstack/router-utils'
 import { transformFuncs } from './constants'
-import { handleCreateServerFileRouteCallExpressionFactory } from './serverFileRoute'
 import { handleCreateIsomorphicFnCallExpression } from './isomorphicFn'
-import { handleCreateMiddlewareCallExpression } from './middleware'
 import {
   handleCreateClientOnlyFnCallExpression,
   handleCreateServerOnlyFnCallExpression,
@@ -19,59 +17,29 @@ import type { GeneratorResult, ParseAstOptions } from '@tanstack/router-utils'
 export type CompileStartFrameworkOptions = 'react' | 'solid'
 
 type Identifiers = { [K in (typeof transformFuncs)[number]]: IdentifierConfig }
-const getIdentifiers = (
-  framework: CompileStartFrameworkOptions,
-): Identifiers => ({
-  createServerRootRoute: {
-    name: 'createServerRootRoute',
-    handleCallExpression: handleCreateServerFileRouteCallExpressionFactory(
-      framework,
-      'createServerRootRoute',
-    ),
-    paths: [],
-  },
-  createServerRoute: {
-    name: 'createServerRoute',
-    handleCallExpression: handleCreateServerFileRouteCallExpressionFactory(
-      framework,
-      'createServerRoute',
-    ),
-    paths: [],
-  },
-  createServerFileRoute: {
-    name: 'createServerFileRoute',
-    handleCallExpression: handleCreateServerFileRouteCallExpressionFactory(
-      framework,
-      'createServerFileRoute',
-    ),
-    paths: [],
-  },
-  createMiddleware: {
-    name: 'createMiddleware',
-    handleCallExpression: handleCreateMiddlewareCallExpression,
-    paths: [],
-  },
-  createServerOnlyFn: {
-    name: 'createServerOnlyFn',
-    handleCallExpression: handleCreateServerOnlyFnCallExpression,
-    paths: [],
-  },
-  createClientOnlyFn: {
-    name: 'createClientOnlyFn',
-    handleCallExpression: handleCreateClientOnlyFnCallExpression,
-    paths: [],
-  },
-  createIsomorphicFn: {
-    name: 'createIsomorphicFn',
-    handleCallExpression: handleCreateIsomorphicFnCallExpression,
-    paths: [],
-  },
-})
 
 export function compileStartOutputFactory(
   framework: CompileStartFrameworkOptions,
 ) {
   return function compileStartOutput(opts: CompileOptions): GeneratorResult {
+    const identifiers: Identifiers = {
+      createServerOnlyFn: {
+        name: 'createServerOnlyFn',
+        handleCallExpression: handleCreateServerOnlyFnCallExpression,
+        paths: [],
+      },
+      createClientOnlyFn: {
+        name: 'createClientOnlyFn',
+        handleCallExpression: handleCreateClientOnlyFnCallExpression,
+        paths: [],
+      },
+      createIsomorphicFn: {
+        name: 'createIsomorphicFn',
+        handleCallExpression: handleCreateIsomorphicFnCallExpression,
+        paths: [],
+      },
+    }
+
     const ast = parseAst(opts)
 
     const doDce = opts.dce ?? true
@@ -81,7 +49,6 @@ export function compileStartOutputFactory(
     babel.traverse(ast, {
       Program: {
         enter(programPath) {
-          const identifiers = getIdentifiers(framework)
           programPath.traverse({
             ImportDeclaration: (path) => {
               if (path.node.source.value !== `@tanstack/${framework}-start`) {

package/src/start-compiler-plugin/constants.ts

@@ -1,9 +1,5 @@
 export const transformFuncs = [
-  'createMiddleware',
   'createServerOnlyFn',
   'createClientOnlyFn',
   'createIsomorphicFn',
-  'createServerRoute',
-  'createServerFileRoute',
-  'createServerRootRoute',
 ] as const

package/src/start-router-plugin/constants.ts

@@ -0,0 +1 @@
+export const SERVER_PROP = 'server'

package/src/start-router-plugin/generator-plugins/routes-manifest-plugin.ts

@@ -9,20 +9,14 @@ import type { GeneratorPlugin } from '@tanstack/router-generator'
 export function routesManifestPlugin(): GeneratorPlugin {
   return {
     name: 'routes-manifest-plugin',
-    onRouteTreesChanged: ({ routeTrees, rootRouteNode }) => {
-      const routeTree = routeTrees.find((tree) => tree.exportName === 'Route')
-      if (!routeTree) {
-        throw new Error(
-          'No route tree found with export name "Route". Please ensure your routes are correctly defined.',
-        )
-      }
+    onRouteTreeChanged: ({ routeTree, rootRouteNode, routeNodes }) => {
       const routesManifest = {
         [rootRouteId]: {
           filePath: rootRouteNode.fullPath,
-          children: routeTree.acc.routeTree.map((d) => d.routePath),
+          children: routeTree.map((d) => d.routePath),
         },
         ...Object.fromEntries(
-          routeTree.acc.routeNodes.map((d) => {
+          routeNodes.map((d) => {
             const filePathId = d.routePath
 
             return [