@tanstack/start-plugin-core 1.167.35 → 1.169.0

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('?')