@tanstack/start-plugin-core 1.167.34 → 1.168.0

package/src/vite/import-protection-plugin/virtualModules.ts

@@ -0,0 +1,122 @@
+import { resolveViteId } from '../../utils'
+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'
+import { VITE_BROWSER_VIRTUAL_PREFIX } from '../../import-protection/constants'
+
+const RESOLVED_MOCK_MODULE_ID = resolveViteId(MOCK_MODULE_ID)
+const RESOLVED_MOCK_BUILD_PREFIX = resolveViteId(MOCK_BUILD_PREFIX)
+const RESOLVED_MOCK_EDGE_PREFIX = resolveViteId(MOCK_EDGE_PREFIX)
+const RESOLVED_MOCK_RUNTIME_PREFIX = resolveViteId(MOCK_RUNTIME_PREFIX)
+const RESOLVED_MARKER_PREFIX = resolveViteId(MARKER_PREFIX)
+const RESOLVED_MARKER_SERVER_ONLY = resolveViteId(`${MARKER_PREFIX}server-only`)
+const RESOLVED_MARKER_CLIENT_ONLY = resolveViteId(`${MARKER_PREFIX}client-only`)
+
+export function resolvedMarkerVirtualModuleId(
+  kind: 'server' | 'client',
+): string {
+  return kind === 'server'
+    ? RESOLVED_MARKER_SERVER_ONLY
+    : RESOLVED_MARKER_CLIENT_ONLY
+}
+
+export function getResolvedVirtualModuleMatchers(): ReadonlyArray<string> {
+  return RESOLVED_VIRTUAL_MODULE_MATCHERS
+}
+
+const RESOLVED_VIRTUAL_MODULE_MATCHERS = [
+  RESOLVED_MOCK_MODULE_ID,
+  RESOLVED_MOCK_BUILD_PREFIX,
+  RESOLVED_MOCK_EDGE_PREFIX,
+  RESOLVED_MOCK_RUNTIME_PREFIX,
+  RESOLVED_MARKER_PREFIX,
+] as const
+
+const 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],
+] as const
+
+export function resolveInternalVirtualModuleId(
+  source: string,
+): string | undefined {
+  if (source.startsWith(VITE_BROWSER_VIRTUAL_PREFIX)) {
+    return resolveInternalVirtualModuleId(
+      `\0${source.slice(VITE_BROWSER_VIRTUAL_PREFIX.length)}`,
+    )
+  }
+
+  if (source === MOCK_MODULE_ID || 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
+    }
+  }
+
+  return undefined
+}
+
+export function loadResolvedVirtualModule(
+  id: string,
+): { code: string } | undefined {
+  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()
+  }
+
+  return 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/vite/plugin.ts

@@ -5,12 +5,12 @@ import {
   createStartConfigContext,
 } from '../config-context'
 import { START_ENVIRONMENT_NAMES } from '../constants'
-import { importProtectionPlugin } from '../import-protection-plugin/plugin'
 import {
   createServerFnBasePath,
   normalizePublicBase,
   shouldRewriteDevBasepath,
 } from '../planning'
+import { importProtectionPlugin } from './import-protection-plugin/plugin'
 import { startCompilerPlugin } from './start-compiler-plugin/plugin'
 import { loadEnvPlugin } from './load-env-plugin/plugin'
 import {
@@ -22,7 +22,6 @@ import {
 import { devServerPlugin } from './dev-server-plugin/plugin'
 import { previewServerPlugin } from './preview-server-plugin/plugin'
 import {
-  createCaptureClientBuildPlugin,
   createDevBaseRewritePlugin,
   createPostBuildPlugin,
   createVirtualClientEntryPlugin,
@@ -36,12 +35,10 @@ import {
 } from './output-directory'
 import { postServerBuild } from './post-server-build'
 import { serializationAdaptersPlugin } from './serialization-adapters-plugin'
-import type { NormalizedClientBuild } from '../types'
 import type {
   TanStackStartVitePluginCoreOptions,
   ViteRscForwardSsrResolverStrategy,
 } from './types'
-import type { StartEnvironmentName } from '../constants'
 import type { TanStackStartViteInputConfig } from './schema'
 import type { PluginOption } from 'vite'
 
@@ -64,16 +61,6 @@ export function tanStackStartVite(
   // we install a URL rewrite middleware instead of erroring.
   let needsDevBaseRewrite = false
 
-  const capturedClientBuild: Partial<
-    Record<StartEnvironmentName, NormalizedClientBuild>
-  > = {}
-
-  function getClientBuild(
-    envName: StartEnvironmentName,
-  ): NormalizedClientBuild | undefined {
-    return capturedClientBuild[envName]
-  }
-
   const environments: Array<{
     name: string
     type: 'client' | 'server'
@@ -242,7 +229,6 @@ export function tanStackStartVite(
       getClientEntry: () => configContext.resolveEntries().entryPaths.client,
     }),
     startManifestPlugin({
-      getClientBuild: () => getClientBuild(START_ENVIRONMENT_NAMES.client),
       getConfig,
     }),
     // When the vite base and router basepath are misaligned (e.g. base: '/_ui/', basepath: '/'),
@@ -266,9 +252,6 @@ export function tanStackStartVite(
     serializationAdaptersPlugin({
       adapters: corePluginOpts.serializationAdapters,
     }),
-    createCaptureClientBuildPlugin({
-      capturedClientBuild,
-    }),
   ]
 }
 

package/src/vite/plugins.ts

@@ -1,13 +1,7 @@
 import { normalizePath } from 'vite'
-import { ENTRY_POINTS, START_ENVIRONMENT_NAMES } from '../constants'
+import { ENTRY_POINTS } from '../constants'
 import { createVirtualModule } from './createVirtualModule'
-import { normalizeViteClientBuild } from './start-manifest-plugin/normalized-client-build'
-import type {
-  GetConfigFn,
-  NormalizedClientBuild,
-  ResolvedStartConfig,
-} from '../types'
-import type { StartEnvironmentName } from '../constants'
+import type { GetConfigFn, ResolvedStartConfig } from '../types'
 import type { PluginOption, ViteBuilder } from 'vite'
 
 export function createVirtualClientEntryPlugin(opts: {
@@ -69,28 +63,3 @@ export function createDevBaseRewritePlugin(opts: {
     },
   }
 }
-
-export function createCaptureClientBuildPlugin(opts: {
-  capturedClientBuild: Partial<
-    Record<StartEnvironmentName, NormalizedClientBuild>
-  >
-}): PluginOption {
-  return {
-    name: 'tanstack-start:core:capture-bundle',
-    applyToEnvironment(environment) {
-      return environment.name === START_ENVIRONMENT_NAMES.client
-    },
-    enforce: 'post',
-    generateBundle(_options, bundle) {
-      const environment = this.environment.name as StartEnvironmentName
-
-      if (environment !== START_ENVIRONMENT_NAMES.client) {
-        throw new Error(
-          `Unexpected environment for client build capture: ${environment}`,
-        )
-      }
-
-      opts.capturedClientBuild[environment] = normalizeViteClientBuild(bundle)
-    },
-  }
-}

package/src/vite/post-server-build.ts

@@ -1,7 +1,6 @@
-import { HEADERS } from '@tanstack/start-server-core'
-import { buildSitemap } from '../build-sitemap'
-import { prerender } from './prerender'
+import { postBuild } from '../post-build'
 import { getClientOutputDirectory } from './output-directory'
+import { prerenderWithVite } from './prerender'
 import type { TanStackStartOutputConfig } from '../schema'
 import type { ViteBuilder } from 'vite'
 
@@ -12,60 +11,18 @@ export async function postServerBuild({
   builder: ViteBuilder
   startConfig: TanStackStartOutputConfig
 }) {
-  // If the user has not set a prerender option, we need to set it to true
-  // if the pages array is not empty and has sub options requiring for prerendering
-  // If the user has explicitly set prerender.enabled, this should be respected
-  if (startConfig.prerender?.enabled !== false) {
-    startConfig.prerender = {
-      ...startConfig.prerender,
-      enabled:
-        startConfig.prerender?.enabled ??
-        startConfig.pages.some((d) =>
-          typeof d === 'string' ? false : !!d.prerender?.enabled,
-        ),
-    }
-  }
-
-  // Setup the options for prerendering the SPA shell (i.e `src/routes/__root.tsx`)
-  if (startConfig.spa?.enabled) {
-    startConfig.prerender = {
-      ...startConfig.prerender,
-      enabled: true,
-    }
-
-    const maskUrl = new URL(startConfig.spa.maskPath, 'http://localhost')
-    if (maskUrl.origin !== 'http://localhost') {
-      throw new Error('spa.maskPath must be a path (no protocol/host)')
-    }
-
-    startConfig.pages.push({
-      path: maskUrl.toString().replace('http://localhost', ''),
-      prerender: {
-        ...startConfig.spa.prerender,
-        headers: {
-          ...startConfig.spa.prerender.headers,
-          [HEADERS.TSS_SHELL]: 'true',
-        },
+  await postBuild({
+    startConfig,
+    adapter: {
+      getClientOutputDirectory() {
+        return getClientOutputDirectory(builder.config)
       },
-      sitemap: {
-        exclude: true,
+      prerender(startConfig) {
+        return prerenderWithVite({
+          startConfig,
+          builder,
+        })
       },
-    })
-  }
-
-  // Run the prerendering process
-  if (startConfig.prerender.enabled) {
-    await prerender({
-      startConfig,
-      builder,
-    })
-  }
-
-  // Run the sitemap build process
-  if (startConfig.sitemap?.enabled) {
-    buildSitemap({
-      startConfig,
-      publicDir: getClientOutputDirectory(builder.config),
-    })
-  }
+    },
+  })
 }

package/src/vite/prerender.ts

@@ -1,50 +1,16 @@
-import { promises as fsp } from 'node:fs'
-import os from 'node:os'
-import path from 'pathe'
-import { joinURL, withBase, withTrailingSlash, withoutBase } from 'ufo'
 import { VITE_ENVIRONMENT_NAMES } from '../constants'
-import { createLogger } from '../utils'
-import { Queue } from '../queue'
+import { prerender } from '../prerender'
+import type { PrerenderHandler } from '../prerender'
+import type { TanStackStartOutputConfig } from '../schema'
 import type { PreviewServer, ResolvedConfig, ViteBuilder } from 'vite'
-import type { Page, TanStackStartOutputConfig } from '../schema'
 
-export async function prerender({
+export async function prerenderWithVite({
   startConfig,
   builder,
 }: {
   startConfig: TanStackStartOutputConfig
   builder: ViteBuilder
 }) {
-  const logger = createLogger('prerender')
-  logger.info('Prerendering pages...')
-
-  if (startConfig.prerender?.enabled) {
-    let pages = startConfig.pages.length ? startConfig.pages : [{ path: '/' }]
-
-    if (startConfig.prerender.autoStaticPathsDiscovery ?? true) {
-      const pagesMap = new Map(pages.map((item) => [item.path, item]))
-      const discoveredPages = globalThis.TSS_PRERENDABLE_PATHS || []
-
-      for (const page of discoveredPages) {
-        if (!pagesMap.has(page.path)) {
-          pagesMap.set(page.path, page)
-        }
-      }
-
-      pages = Array.from(pagesMap.values())
-    }
-
-    startConfig.pages = pages
-  }
-
-  const routerBasePath = joinURL('/', startConfig.router.basepath ?? '')
-  const routerBaseUrl = new URL(routerBasePath, 'http://localhost')
-
-  startConfig.pages = validateAndNormalizePrerenderPages(
-    startConfig.pages,
-    routerBaseUrl,
-  )
-
   const serverEnv = builder.environments[VITE_ENVIRONMENT_NAMES.server]
 
   if (!serverEnv) {
@@ -68,203 +34,23 @@ export async function prerender({
   const previewServer = await startPreviewServer(serverEnv.config)
   const baseUrl = getResolvedUrl(previewServer)
 
-  const isRedirectResponse = (res: Response) => {
-    return res.status >= 300 && res.status < 400 && res.headers.get('location')
-  }
-
-  async function localFetch(
-    path: string,
-    options?: RequestInit,
-    maxRedirects: number = 5,
-  ): Promise<Response> {
-    const url = new URL(path, baseUrl)
-    const request = new Request(url, options)
-    const response = await fetch(request)
-
-    if (isRedirectResponse(response) && maxRedirects > 0) {
-      const location = response.headers.get('location')!
-      if (location.startsWith('http://localhost') || location.startsWith('/')) {
-        const newUrl = location.replace('http://localhost', '')
-        return localFetch(newUrl, options, maxRedirects - 1)
-      }
-
-      logger.warn(`Skipping redirect to external location: ${location}`)
-    }
-
-    return response
-  }
-
-  try {
-    const pages = await prerenderPages({ outputDir })
-
-    logger.info(`Prerendered ${pages.length} pages:`)
-    pages.forEach((page) => {
-      logger.info(`- ${page}`)
-    })
-  } catch (error) {
-    logger.error(error)
-  } finally {
-    await previewServer.close()
+  const handler: PrerenderHandler = {
+    getClientOutputDirectory() {
+      return outputDir
+    },
+    request(path, options) {
+      const url = new URL(path, baseUrl)
+      return fetch(new Request(url, options))
+    },
+    close() {
+      return previewServer.close()
+    },
   }
 
-  function extractLinks(html: string): Array<string> {
-    const linkRegex = /<a[^>]+href=["']([^"']+)["'][^>]*>/g
-    const links: Array<string> = []
-    let match: RegExpExecArray | null
-
-    while ((match = linkRegex.exec(html)) !== null) {
-      const href = match[1]
-      if (href && (href.startsWith('/') || href.startsWith('./'))) {
-        links.push(href)
-      }
-    }
-
-    return links
-  }
-
-  async function prerenderPages({ outputDir }: { outputDir: string }) {
-    const seen = new Set<string>()
-    const prerendered = new Set<string>()
-    const retriesByPath = new Map<string, number>()
-    const concurrency = startConfig.prerender?.concurrency ?? os.cpus().length
-    logger.info(`Concurrency: ${concurrency}`)
-    const queue = new Queue({ concurrency })
-    const routerBasePath = joinURL('/', startConfig.router.basepath ?? '')
-
-    const routerBaseUrl = new URL(routerBasePath, 'http://localhost')
-    startConfig.pages = validateAndNormalizePrerenderPages(
-      startConfig.pages,
-      routerBaseUrl,
-    )
-
-    startConfig.pages.forEach((page) => addCrawlPageTask(page))
-
-    if (queue.isSettled()) {
-      logger.info('No pages matched prerender filter; skipping.')
-      return Array.from(prerendered)
-    }
-
-    await queue.start()
-
-    return Array.from(prerendered)
-
-    function addCrawlPageTask(page: Page) {
-      if (seen.has(page.path)) return
-
-      seen.add(page.path)
-
-      if (page.fromCrawl) {
-        startConfig.pages.push(page)
-      }
-
-      if (!(page.prerender?.enabled ?? true)) return
-
-      if (
-        startConfig.prerender?.filter &&
-        !startConfig.prerender.filter(page)
-      ) {
-        return
-      }
-
-      const prerenderOptions = {
-        ...startConfig.prerender,
-        ...page.prerender,
-      }
-
-      queue.add(async () => {
-        logger.info(`Crawling: ${page.path}`)
-        const retries = retriesByPath.get(page.path) || 0
-        try {
-          const res = await localFetch(
-            withTrailingSlash(withBase(page.path, routerBasePath)),
-            {
-              headers: {
-                ...(prerenderOptions.headers ?? {}),
-              },
-            },
-            prerenderOptions.maxRedirects,
-          )
-
-          if (!res.ok) {
-            if (isRedirectResponse(res)) {
-              logger.warn(`Max redirects reached for ${page.path}`)
-            }
-            throw new Error(`Failed to fetch ${page.path}: ${res.statusText}`, {
-              cause: res,
-            })
-          }
-
-          const cleanPagePath = (
-            prerenderOptions.outputPath || page.path
-          ).split(/[?#]/)[0]!
-
-          const contentType = res.headers.get('content-type') || ''
-          const isImplicitHTML =
-            !cleanPagePath.endsWith('.html') && contentType.includes('html')
-
-          const routeWithIndex = cleanPagePath.endsWith('/')
-            ? cleanPagePath + 'index'
-            : cleanPagePath
-
-          const isSpaShell =
-            startConfig.spa?.prerender.outputPath === cleanPagePath
-
-          let htmlPath: string
-          if (isSpaShell) {
-            htmlPath = cleanPagePath + '.html'
-          } else if (
-            cleanPagePath.endsWith('/') ||
-            (prerenderOptions.autoSubfolderIndex ?? true)
-          ) {
-            htmlPath = joinURL(cleanPagePath, 'index.html')
-          } else {
-            htmlPath = cleanPagePath + '.html'
-          }
-
-          const filename = withoutBase(
-            isImplicitHTML ? htmlPath : routeWithIndex,
-            routerBasePath,
-          )
-
-          const html = await res.text()
-
-          const filepath = path.join(outputDir, filename)
-
-          await fsp.mkdir(path.dirname(filepath), {
-            recursive: true,
-          })
-
-          await fsp.writeFile(filepath, html)
-
-          prerendered.add(page.path)
-
-          const newPage = await prerenderOptions.onSuccess?.({ page, html })
-
-          if (newPage) {
-            Object.assign(page, newPage)
-          }
-
-          if (prerenderOptions.crawlLinks ?? true) {
-            const links = extractLinks(html)
-            for (const link of links) {
-              addCrawlPageTask({ path: link, fromCrawl: true })
-            }
-          }
-        } catch (error) {
-          if (retries < (prerenderOptions.retryCount ?? 0)) {
-            logger.warn(`Encountered error, retrying: ${page.path} in 500ms`)
-            await new Promise((resolve) =>
-              setTimeout(resolve, prerenderOptions.retryDelay),
-            )
-            retriesByPath.set(page.path, retries + 1)
-            addCrawlPageTask(page)
-          } else if (prerenderOptions.failOnError ?? true) {
-            throw error
-          }
-        }
-      })
-    }
-  }
+  return prerender({
+    startConfig,
+    handler,
+  })
 }
 
 async function startPreviewServer(
@@ -299,30 +85,3 @@ function getResolvedUrl(previewServer: PreviewServer): URL {
 
   return new URL(baseUrl)
 }
-
-function validateAndNormalizePrerenderPages(
-  pages: Array<Page>,
-  routerBaseUrl: URL,
-): Array<Page> {
-  return pages.map((page) => {
-    let url: URL
-    try {
-      url = new URL(page.path, routerBaseUrl)
-    } catch (err) {
-      throw new Error(`prerender page path must be relative: ${page.path}`, {
-        cause: err,
-      })
-    }
-
-    if (url.origin !== 'http://localhost') {
-      throw new Error(`prerender page path must be relative: ${page.path}`)
-    }
-
-    const decodedPathname = decodeURIComponent(url.pathname)
-
-    return {
-      ...page,
-      path: decodedPathname + url.search + url.hash,
-    }
-  })
-}

package/src/vite/start-compiler-plugin/hot-update.ts

@@ -0,0 +1,24 @@
+import type { EnvironmentModuleNode } from 'vite'
+
+export function mergeHotUpdateModules(
+  currentModules: Array<EnvironmentModuleNode>,
+  additionalModules: Array<EnvironmentModuleNode>,
+): Array<EnvironmentModuleNode> | undefined {
+  if (additionalModules.length === 0) {
+    return undefined
+  }
+
+  const mergedModules = currentModules.slice()
+  const seenModules = new Set(currentModules)
+
+  for (const mod of additionalModules) {
+    if (seenModules.has(mod)) {
+      continue
+    }
+
+    seenModules.add(mod)
+    mergedModules.push(mod)
+  }
+
+  return mergedModules
+}

package/src/vite/start-compiler-plugin/module-specifier.ts

@@ -3,16 +3,21 @@ import type { DevServerFnModuleSpecifierEncoder } from '../../start-compiler/typ
 export function createViteDevServerFnModuleSpecifierEncoder(
   root: string,
 ): DevServerFnModuleSpecifierEncoder {
-  const rootWithTrailingSlash = root.endsWith('/') ? root : `${root}/`
+  const normalizedRoot = root.replace(/\\/g, '/')
+  const rootWithTrailingSlash = normalizedRoot.endsWith('/')
+    ? normalizedRoot
+    : `${normalizedRoot}/`
 
   return ({ extractedFilename }) => {
-    let file = extractedFilename
+    const normalizedFile = extractedFilename.replace(/\\/g, '/')
 
-    if (file.startsWith(rootWithTrailingSlash)) {
-      file = file.slice(rootWithTrailingSlash.length)
+    if (normalizedFile.startsWith(rootWithTrailingSlash)) {
+      return `/${normalizedFile.slice(rootWithTrailingSlash.length)}`
     }
 
-    return `/@id/${file}`
+    return normalizedFile.startsWith('/')
+      ? `/@fs${normalizedFile}`
+      : `/@fs/${normalizedFile}`
   }
 }
 
@@ -23,6 +28,11 @@ export function decodeViteDevServerModuleSpecifier(
 
   if (sourceFile.startsWith('/@id/')) {
     sourceFile = sourceFile.slice('/@id/'.length)
+  } else if (sourceFile.startsWith('/@fs/')) {
+    sourceFile = sourceFile.slice('/@fs'.length)
+    sourceFile = sourceFile.replace(/^\/([A-Za-z]:\/)/, '$1')
+  } else if (sourceFile.startsWith('/')) {
+    sourceFile = sourceFile.slice(1)
   }
 
   const queryIndex = sourceFile.indexOf('?')