@remix-run/assets 0.6.0 → 0.7.0

package/src/lib/styles/emit.ts

@@ -4,7 +4,7 @@ import {
   createAssetServerCompilationError,
   isAssetServerCompilationError,
 } from '../compilation-error.ts'
-import { hashContent } from '../fingerprint.ts'
+import { formatFingerprintedPathname, hashContent } from '../fingerprint.ts'
 import { composeSourceMaps } from '../source-maps.ts'
 import type { AssetServerCompilationError } from '../compilation-error.ts'
 import type { ResolvedStyle } from './resolve.ts'
@@ -12,12 +12,12 @@ import type { ResolvedStyle } from './resolve.ts'
 export type EmittedAsset = {
   content: string
   etag: string
+  fingerprint: string
 }
 
 export type EmittedStyle = {
   code: EmittedAsset
   fingerprint: string | null
-  importUrls: string[]
   sourceMap: EmittedAsset | null
 }
 
@@ -34,6 +34,7 @@ type EmitResult =
 export async function emitResolvedStyle(
   resolvedStyle: ResolvedStyle,
   options: {
+    fingerprintAssets: boolean
     getServedFileUrl?(
       identityPath: string,
       options: {
@@ -45,30 +46,32 @@ export async function emitResolvedStyle(
   },
 ): Promise<EmitResult> {
   try {
-    let importUrls = await Promise.all(
-      resolvedStyle.deps.map((depPath) => options.getServedUrl(depPath)),
-    )
     let rewriteResult = await rewriteDependencies(resolvedStyle, options)
     let finalCode = rewriteResult.code
+    let sourceMap = rewriteResult.sourceMap
+      ? await createEmittedAsset(rewriteResult.sourceMap)
+      : null
 
     if (rewriteResult.sourceMap) {
       if (options.sourceMaps === 'inline') {
         let encoded = Buffer.from(rewriteResult.sourceMap).toString('base64')
         finalCode += `\n/*# sourceMappingURL=data:application/json;base64,${encoded} */`
       } else if (options.sourceMaps === 'external') {
-        finalCode += `\n/*# sourceMappingURL=${await options.getServedUrl(resolvedStyle.identityPath)}.map */`
+        finalCode += `\n/*# sourceMappingURL=${formatFingerprintedPathname(
+          resolvedStyle.stableUrlPathname,
+          options.fingerprintAssets && sourceMap ? sourceMap.fingerprint : null,
+        )}.map */`
       }
     }
 
+    let code = await createEmittedAsset(finalCode)
+
     return {
       ok: true,
       value: {
-        code: await createEmittedAsset(finalCode),
-        fingerprint: resolvedStyle.fingerprint,
-        importUrls,
-        sourceMap: rewriteResult.sourceMap
-          ? await createEmittedAsset(rewriteResult.sourceMap)
-          : null,
+        code,
+        fingerprint: options.fingerprintAssets ? code.fingerprint : null,
+        sourceMap,
       },
     }
   } catch (error) {
@@ -192,9 +195,11 @@ async function getServedFileUrl(
 }
 
 async function createEmittedAsset(content: string): Promise<EmittedAsset> {
+  let fingerprint = await hashContent(content)
   return {
     content,
-    etag: `W/"${await hashContent(content)}"`,
+    etag: `W/"${fingerprint}"`,
+    fingerprint,
   }
 }
 

package/src/lib/styles/resolve.ts

@@ -38,7 +38,6 @@ type ResolvedDependency =
 export type ResolvedStyle = {
   dependencies: ResolvedDependency[]
   deps: string[]
-  fingerprint: string | null
   identityPath: string
   rawCode: string
   resolvedPath: string
@@ -131,7 +130,6 @@ export async function resolveStyle(
     value: {
       dependencies,
       deps: [...deps],
-      fingerprint: transformed.fingerprint,
       identityPath: record.identityPath,
       rawCode: transformed.rawCode,
       resolvedPath: transformed.resolvedPath,

package/src/lib/styles/transform.ts

@@ -5,7 +5,6 @@ import {
   createAssetServerCompilationError,
   isAssetServerCompilationError,
 } from '../compilation-error.ts'
-import { generateFingerprint } from '../fingerprint.ts'
 import type { ModuleTracking } from '../module-store.ts'
 import { rewriteSourceMapSources, stringifySourceMap } from '../source-maps.ts'
 import type { AssetServerCompilationError } from '../compilation-error.ts'
@@ -25,7 +24,6 @@ type TransformedStyleDependency =
     }
 
 export type TransformedStyle = {
-  fingerprint: string | null
   identityPath: string
   rawCode: string
   resolvedPath: string
@@ -49,7 +47,6 @@ type TransformResult = {
 )
 
 export type TransformArgs = {
-  buildId: string | null
   isWatchIgnored(filePath: string): boolean
   minify: boolean
   routes: CompiledRoutes
@@ -149,13 +146,6 @@ export async function transformStyle(
         trackedFiles,
       },
       value: {
-        fingerprint:
-          args.buildId === null
-            ? null
-            : await generateFingerprint({
-                buildId: args.buildId,
-                content: sourceText,
-              }),
         identityPath: record.identityPath,
         rawCode: Buffer.from(transformResult.code).toString('utf8'),
         resolvedPath,

package/src/lib/virtual-store.ts

@@ -0,0 +1,124 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+import {
+  getFilePathBaseName,
+  getFilePathDirectory,
+  normalizeFilePath,
+  resolveFilePath,
+} from './paths.ts'
+import { resolveMountFileRoot } from './routes.ts'
+
+const modulesStateFileName = '.modules.yaml'
+const virtualStoreBasePath = '/__@remix/virtual-store'
+const virtualStoreDirLineRE = /^virtualStoreDir:[ \t]*(.+)$/m
+
+// pnpm's global virtual store links packages from a machine-wide directory, so package realpaths
+// land outside `rootDir` and would otherwise have no public URL. The store location comes from
+// `node_modules/.modules.yaml`, which pnpm rewrites on every install.
+export function getVirtualStoreMountConfigs(options: {
+  mounts: Readonly<Record<string, string>>
+  rootDir: string
+}): {
+  mounts: Record<string, string>
+  rootDir: string
+}[] {
+  let virtualStoreDir = findVirtualStoreDir(options.rootDir)
+  if (virtualStoreDir === null) return []
+  // A store inside a mount, such as pnpm's default `node_modules/.pnpm`, already has URLs.
+  if (isWithinMounts(virtualStoreDir, options)) return []
+
+  return [
+    {
+      mounts: {
+        [virtualStoreBasePath]: getFilePathBaseName(virtualStoreDir),
+      },
+      rootDir: getFilePathDirectory(virtualStoreDir),
+    },
+  ]
+}
+
+function findVirtualStoreDir(rootDir: string): string | null {
+  let directory = normalizeFilePath(rootDir)
+
+  // Workspace members share the workspace root's file, so walk up to the nearest one.
+  while (true) {
+    let modulesDir = `${directory}/node_modules`
+    let modulesState = readModulesState(`${modulesDir}/${modulesStateFileName}`)
+    if (modulesState !== null) {
+      let virtualStoreDir = readVirtualStoreDir(modulesState)
+      if (virtualStoreDir === null) return null
+      return realpathDirectory(resolveFilePath(modulesDir, virtualStoreDir))
+    }
+
+    let parentDirectory = normalizeFilePath(path.dirname(directory))
+    if (parentDirectory === directory) return null
+    directory = parentDirectory
+  }
+}
+
+function readVirtualStoreDir(modulesState: string): string | null {
+  // pnpm 10.34 and later write JSON, earlier versions write YAML, and package managers that
+  // mirror the global virtual store write either one. Reading the one scalar this needs keeps
+  // both formats working without a YAML parser.
+  try {
+    let parsedState = JSON.parse(modulesState) as unknown
+    if (parsedState === null || typeof parsedState !== 'object') return null
+
+    let virtualStoreDir = (parsedState as Record<string, unknown>).virtualStoreDir
+    return typeof virtualStoreDir === 'string' ? virtualStoreDir : null
+  } catch {
+    let match = virtualStoreDirLineRE.exec(modulesState)
+    return match === null ? null : unquoteScalar(match[1].trim())
+  }
+}
+
+function unquoteScalar(value: string): string {
+  let quote = value[0]
+  if (value.length > 1 && (quote === "'" || quote === '"') && value.endsWith(quote)) {
+    return value.slice(1, -1)
+  }
+
+  return value
+}
+
+function isWithinMounts(
+  directory: string,
+  options: {
+    mounts: Readonly<Record<string, string>>
+    rootDir: string
+  },
+): boolean {
+  return Object.values(options.mounts).some((fileRoot) => {
+    let mountRoot = resolveMountFileRoot(options.rootDir, fileRoot)
+    return directory === mountRoot || directory.startsWith(`${mountRoot}/`)
+  })
+}
+
+function readModulesState(filePath: string): string | null {
+  try {
+    return fs.readFileSync(filePath, 'utf-8')
+  } catch (error) {
+    if (isPathNotFoundError(error)) return null
+    throw error
+  }
+}
+
+function realpathDirectory(filePath: string): string | null {
+  try {
+    let realPath = fs.realpathSync(filePath)
+    return fs.statSync(realPath).isDirectory() ? normalizeFilePath(realPath) : null
+  } catch (error) {
+    if (isPathNotFoundError(error)) return null
+    throw error
+  }
+}
+
+function isPathNotFoundError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    'code' in error &&
+    ((error as NodeJS.ErrnoException).code === 'ENOENT' ||
+      (error as NodeJS.ErrnoException).code === 'ENOTDIR')
+  )
+}