Add ignore comments

Author: mischnic

packages/next/src/server/base-server.ts

@@ -439,7 +439,7 @@ export default abstract class Server<
     this.experimentalTestProxy = experimentalTestProxy
     this.serverOptions = options
 
-    this.dir = path.resolve(dir)
+    this.dir = path.resolve(/* turbopackIgnore: true */ dir)
 
     this.quiet = quiet
     this.loadEnvConfig({ dev })
@@ -453,7 +453,10 @@ export default abstract class Server<
       this.fetchHostname = formatHostname(this.hostname)
     }
     this.port = port
-    this.distDir = path.join(this.dir, this.nextConfig.distDir)
+    this.distDir = path.join(
+      /* turbopackIgnore: true */ this.dir,
+      this.nextConfig.distDir
+    )
     this.publicDir = this.getPublicDir()
     this.hasStaticDir = !minimalMode && this.getHasStaticDir()
 

packages/next/src/server/image-optimizer.ts

@@ -141,6 +141,7 @@ async function writeToCacheDir(
   upstreamEtag: string
 ) {
   const filename = join(
+    /* turbopackIgnore: true */
     dir,
     `${maxAge}.${expireAt}.${etag}.${upstreamEtag}.${extension}`
   )
@@ -464,20 +465,25 @@ export class ImageOptimizerCache {
     distDir: string
     nextConfig: NextConfigComplete
   }) {
-    this.cacheDir = join(distDir, 'cache', 'images')
+    this.cacheDir = join(/* turbopackIgnore: true */ distDir, 'cache', 'images')
     this.nextConfig = nextConfig
   }
 
   async get(cacheKey: string): Promise<IncrementalResponseCacheEntry | null> {
     try {
-      const cacheDir = join(this.cacheDir, cacheKey)
+      const cacheDir = join(/* turbopackIgnore: true */ this.cacheDir, cacheKey)
       const files = await promises.readdir(cacheDir)
       const now = Date.now()
 
       for (const file of files) {
         const [maxAgeSt, expireAtSt, etag, upstreamEtag, extension] =
           file.split('.', 5)
-        const buffer = await promises.readFile(join(cacheDir, file))
+        const buffer = await promises.readFile(
+          /* turbopackIgnore: true */ join(
+            /* turbopackIgnore: true */ cacheDir,
+            file
+          )
+        )
         const expireAt = Number(expireAtSt)
         const maxAge = Number(maxAgeSt)
 
@@ -530,7 +536,7 @@ export class ImageOptimizerCache {
 
     try {
       await writeToCacheDir(
-        join(this.cacheDir, cacheKey),
+        join(/* turbopackIgnore: true */ this.cacheDir, cacheKey),
         value.extension,
         revalidate,
         expireAt,

packages/next/src/server/load-components.ts

@@ -177,9 +177,13 @@ async function loadComponentsImpl<N = any>({
 
   let reactLoadableManifestPath
   if (!process.env.TURBOPACK) {
-    reactLoadableManifestPath = join(distDir, REACT_LOADABLE_MANIFEST)
+    reactLoadableManifestPath = join(
+      /* turbopackIgnore: true */ distDir,
+      REACT_LOADABLE_MANIFEST
+    )
   } else if (isAppPath) {
     reactLoadableManifestPath = join(
+      /* turbopackIgnore: true */
       distDir,
       'server',
       'app',
@@ -188,6 +192,7 @@ async function loadComponentsImpl<N = any>({
     )
   } else {
     reactLoadableManifestPath = join(
+      /* turbopackIgnore: true */
       distDir,
       'server',
       'pages',
@@ -213,7 +218,7 @@ async function loadComponentsImpl<N = any>({
     subresourceIntegrityManifest,
   ] = await Promise.all([
     loadManifestWithRetries<BuildManifest>(
-      join(distDir, BUILD_MANIFEST),
+      join(/* turbopackIgnore: true */ distDir, BUILD_MANIFEST),
       manifestLoadAttempts
     ),
     tryLoadManifestWithRetries<ReactLoadableManifest>(
@@ -224,12 +229,16 @@ async function loadComponentsImpl<N = any>({
     isAppPath || process.env.TURBOPACK
       ? undefined
       : loadManifestWithRetries<DynamicCssManifest>(
-          join(distDir, `${DYNAMIC_CSS_MANIFEST}.json`),
+          join(
+            /* turbopackIgnore: true */ distDir,
+            `${DYNAMIC_CSS_MANIFEST}.json`
+          ),
           manifestLoadAttempts
         ).catch(() => undefined),
     isAppPath && hasClientManifest
       ? tryLoadClientReferenceManifest(
           join(
+            /* turbopackIgnore: true */
             distDir,
             'server',
             'app',
@@ -241,13 +250,21 @@ async function loadComponentsImpl<N = any>({
       : undefined,
     isAppPath
       ? loadManifestWithRetries<ActionManifest>(
-          join(distDir, 'server', SERVER_REFERENCE_MANIFEST + '.json'),
+          join(
+            /* turbopackIgnore: true */ distDir,
+            'server',
+            SERVER_REFERENCE_MANIFEST + '.json'
+          ),
           manifestLoadAttempts
         ).catch(() => null)
       : null,
     sriEnabled
       ? loadManifestWithRetries<DeepReadonly<Record<string, string>>>(
-          join(distDir, 'server', SUBRESOURCE_INTEGRITY_MANIFEST + '.json')
+          join(
+            /* turbopackIgnore: true */ distDir,
+            'server',
+            SUBRESOURCE_INTEGRITY_MANIFEST + '.json'
+          )
         ).catch(() => undefined)
       : undefined,
   ])

packages/next/src/server/next-server.ts

@@ -353,7 +353,10 @@ export default class NextNodeServer extends BaseServer<
       interceptTestApis()
     }
 
-    this.middlewareManifestPath = join(this.serverDistDir, MIDDLEWARE_MANIFEST)
+    this.middlewareManifestPath = join(
+      /* turbopackIgnore: true */ this.serverDistDir,
+      MIDDLEWARE_MANIFEST
+    )
 
     // This is just optimization to fire prepare as soon as possible. It will be
     // properly awaited later. We add the catch here to ensure that it does not
@@ -537,24 +540,29 @@ export default class NextNodeServer extends BaseServer<
   }
 
   protected getPublicDir(): string {
-    return join(this.dir, CLIENT_PUBLIC_FILES_PATH)
+    return join(/* turbopackIgnore: true */ this.dir, CLIENT_PUBLIC_FILES_PATH)
   }
 
   protected getHasStaticDir(): boolean {
-    return fs.existsSync(join(this.dir, 'static'))
+    return fs.existsSync(
+      /* turbopackIgnore: true */ join(
+        /* turbopackIgnore: true */ this.dir,
+        'static'
+      )
+    )
   }
 
   protected getPagesManifest(): PagesManifest | undefined {
     return loadManifest(
-      join(this.serverDistDir, PAGES_MANIFEST)
+      join(/* turbopackIgnore: true */ this.serverDistDir, PAGES_MANIFEST)
     ) as PagesManifest
   }
 
   protected getAppPathsManifest(): PagesManifest | undefined {
     if (!this.enabledDirectories.app) return undefined
 
     return loadManifest(
-      join(this.serverDistDir, APP_PATHS_MANIFEST)
+      join(/* turbopackIgnore: true */ this.serverDistDir, APP_PATHS_MANIFEST)
     ) as PagesManifest
   }
 
@@ -579,9 +587,14 @@ export default class NextNodeServer extends BaseServer<
   }
 
   protected getBuildId(): string {
-    const buildIdFile = join(this.distDir, BUILD_ID_FILE)
+    const buildIdFile = join(
+      /* turbopackIgnore: true */ this.distDir,
+      BUILD_ID_FILE
+    )
     try {
-      return fs.readFileSync(buildIdFile, 'utf8').trim()
+      return fs
+        .readFileSync(/* turbopackIgnore: true */ buildIdFile, 'utf8')
+        .trim()
     } catch (err: any) {
       if (err.code === 'ENOENT') {
         throw new Error(
@@ -959,7 +972,11 @@ export default class NextNodeServer extends BaseServer<
 
   protected getNextFontManifest(): NextFontManifest | undefined {
     return loadManifest(
-      join(this.distDir, 'server', NEXT_FONT_MANIFEST + '.json')
+      join(
+        /* turbopackIgnore: true */ this.distDir,
+        'server',
+        NEXT_FONT_MANIFEST + '.json'
+      )
     ) as NextFontManifest
   }
 
@@ -1523,17 +1540,25 @@ export default class NextNodeServer extends BaseServer<
 
     return {
       name: pageInfo.name,
-      paths: pageInfo.files.map((file) => join(this.distDir, file)),
+      paths: pageInfo.files.map((file) =>
+        join(/* turbopackIgnore: true */ this.distDir, file)
+      ),
       wasm: (pageInfo.wasm ?? []).map((binding) => ({
         ...binding,
-        filePath: join(this.distDir, binding.filePath),
+        filePath: join(
+          /* turbopackIgnore: true */ this.distDir,
+          binding.filePath
+        ),
       })),
       assets:
         pageInfo.assets &&
         pageInfo.assets.map((binding) => {
           return {
             ...binding,
-            filePath: join(this.distDir, binding.filePath),
+            filePath: join(
+              /* turbopackIgnore: true */ this.distDir,
+              binding.filePath
+            ),
           }
         }),
       env: pageInfo.env,
@@ -1545,14 +1570,26 @@ export default class NextNodeServer extends BaseServer<
       try {
         const functionsConfig = this.renderOpts.dev
           ? {}
-          : require(join(this.distDir, 'server', FUNCTIONS_CONFIG_MANIFEST))
+          : require(
+              join(
+                /* turbopackIgnore: true */ this.distDir,
+                'server',
+                FUNCTIONS_CONFIG_MANIFEST
+              )
+            )
 
         if (
           this.renderOpts.dev ||
           functionsConfig?.functions?.['/_middleware']
         ) {
           // if used with top level await, this will be a promise
-          return require(join(this.distDir, 'server', 'middleware.js'))
+          return require(
+            join(
+              /* turbopackIgnore: true */ this.distDir,
+              'server',
+              'middleware.js'
+            )
+          )
         }
       } catch (err) {
         if (
@@ -1889,7 +1926,7 @@ export default class NextNodeServer extends BaseServer<
     }
 
     this._cachedPreviewManifest = loadManifest(
-      join(this.distDir, PRERENDER_MANIFEST)
+      join(/* turbopackIgnore: true */ this.distDir, PRERENDER_MANIFEST)
     ) as PrerenderManifest
 
     return this._cachedPreviewManifest
@@ -1898,7 +1935,10 @@ export default class NextNodeServer extends BaseServer<
   protected getRoutesManifest(): NormalizedRouteManifest | undefined {
     return getTracer().trace(
       NextNodeServerSpan.getRoutesManifest,
-      () => loadManifest(join(this.distDir, ROUTES_MANIFEST)) as RoutesManifest
+      () =>
+        loadManifest(
+          join(/* turbopackIgnore: true */ this.distDir, ROUTES_MANIFEST)
+        ) as RoutesManifest
     )
   }
 
@@ -2060,7 +2100,10 @@ export default class NextNodeServer extends BaseServer<
     if (this._serverDistDir) {
       return this._serverDistDir
     }
-    const serverDistDir = join(this.distDir, SERVER_DIRECTORY)
+    const serverDistDir = join(
+      /* turbopackIgnore: true */ this.distDir,
+      SERVER_DIRECTORY
+    )
     this._serverDistDir = serverDistDir
     return serverDistDir
   }

packages/next/src/server/require.ts

@@ -29,17 +29,23 @@ export function getMaybePagePath(
   // If we have a cached path, we can return it directly.
   if (pagePath) return pagePath
 
-  const serverBuildPath = path.join(distDir, SERVER_DIRECTORY)
+  const serverBuildPath = path.join(
+    /* turbopackIgnore: true */ distDir,
+    SERVER_DIRECTORY
+  )
   let appPathsManifest: undefined | PagesManifest
 
   if (isAppPath) {
     appPathsManifest = loadManifest(
-      path.join(serverBuildPath, APP_PATHS_MANIFEST),
+      path.join(
+        /* turbopackIgnore: true */ serverBuildPath,
+        APP_PATHS_MANIFEST
+      ),
       !isDev
     ) as PagesManifest
   }
   const pagesManifest = loadManifest(
-    path.join(serverBuildPath, PAGES_MANIFEST),
+    path.join(/* turbopackIgnore: true */ serverBuildPath, PAGES_MANIFEST),
     !isDev
   ) as PagesManifest
 
@@ -78,7 +84,7 @@ export function getMaybePagePath(
     return null
   }
 
-  pagePath = path.join(serverBuildPath, pagePath)
+  pagePath = path.join(/* turbopackIgnore: true */ serverBuildPath, pagePath)
 
   pagePathCache?.set(cacheKey, pagePath)
   return pagePath
@@ -106,14 +112,16 @@ export async function requirePage(
 ): Promise<any> {
   const pagePath = getPagePath(page, distDir, undefined, isAppPath)
   if (pagePath.endsWith('.html')) {
-    return promises.readFile(pagePath, 'utf8').catch((err) => {
-      throw new MissingStaticPage(page, err.message)
-    })
+    return promises
+      .readFile(/* turbopackIgnore: true */ pagePath, 'utf8')
+      .catch((err) => {
+        throw new MissingStaticPage(page, err.message)
+      })
   }
 
   const mod = process.env.NEXT_MINIMAL
     ? // @ts-ignore
       __non_webpack_require__(pagePath)
-    : require(pagePath)
+    : require(/* turbopackIgnore: true */ pagePath)
   return mod
 }