@remix-run/assets 0.5.0 → 0.7.0

package/src/lib/scripts/resolve.ts

@@ -17,6 +17,7 @@ import { normalizeFilePath } from '../paths.ts'
 import type { CompiledRoutes } from '../routes.ts'
 import type { ResolveModuleResult, TransformedModule } from './transform.ts'
 import type { EmittedModule } from './emit.ts'
+import { isBareImportSpecifier } from './specifiers.ts'
 
 type ScriptRecord = ModuleRecord<TransformedModule, ResolvedModule, EmittedModule>
 
@@ -31,14 +32,24 @@ export const supportedScriptExtensions = ['.ts', '.tsx', '.js', '.jsx', '.mts',
 const supportedScriptExtensionSet = new Set<string>(supportedScriptExtensions)
 
 type ResolvedImport = {
+  compiledSpecifier: string
   depPath: string
   end: number
   quote?: '"' | "'" | '`'
+  scopePathname?: string
+  specifier: string
   start: number
 }
 
 type ResolvedHmrAcceptedDependency = ResolvedImport
 
+type PendingBareImportScope = {
+  imported: ResolvedImport
+  resolvedIdentityPath: string
+  specifier: string
+  trackedResolution: RelativeImportResolution | null
+}
+
 type RelativeImportResolution = {
   candidatePaths: readonly string[]
   candidatePrefixes: readonly string[]
@@ -51,7 +62,6 @@ type TrackedResolution = RelativeImportResolution & {
 
 export type ResolvedModule = {
   deps: string[]
-  fingerprint: string | null
   hmr: Omit<TransformedModule['hmr'], 'acceptedDeps'> & {
     acceptedDeps: ResolvedHmrAcceptedDependency[]
   }
@@ -61,6 +71,7 @@ export type ResolvedModule = {
   rawCode: string
   resolvedPath: string
   sourceMap: string | null
+  staticDeps: string[]
   stableUrlPathname: string
 }
 
@@ -78,10 +89,13 @@ type ResolveResult = {
 )
 
 export type ResolveArgs = {
+  concurrency: number
+  isDirectoryResolutionFileIndependent(directory: string): boolean
   isAllowed(absolutePath: string): boolean
   isWatchIgnored(filePath: string): boolean
   resolveModulePath(absolutePath: string): ResolveModuleResult | null
   resolverFactory: ResolverFactory
+  resolveDirectorySpecifierIdentity(directory: string, specifier: string): Promise<string | null>
   routes: CompiledRoutes
 }
 
@@ -121,8 +135,10 @@ export async function resolveModule(
   }
 
   let importsWithPaths: ResolvedImport[] = []
+  let pendingBareImportScopes: PendingBareImportScope[] = []
   let acceptedDepsWithPaths: ResolvedHmrAcceptedDependency[] = []
   let deps = new Set<string>()
+  let staticDeps = new Set<string>()
 
   for (let unresolved of transformed.unresolvedImports) {
     let displaySpecifier = getDisplayImportSpecifier(unresolved.specifier)
@@ -137,7 +153,7 @@ export async function resolveModule(
       return failResolve(
         createAssetServerCompilationError(
           `Failed to resolve import "${displaySpecifier}" in ${transformed.resolvedPath}. ` +
-            `Ensure it resolves to a file within the configured asset server fileMap, or mark it as external.`,
+            `Ensure it resolves to a file within a configured asset server mount, or mark it as external.`,
           {
             code: 'IMPORT_RESOLUTION_FAILED',
           },
@@ -186,10 +202,10 @@ export async function resolveModule(
     if (!stableUrlPathname) {
       return failResolve(
         createAssetServerCompilationError(
-          `Import "${displaySpecifier}" in ${transformed.resolvedPath}, resolved to "${resolvedImport.identityPath}", is outside all configured fileMap entries. ` +
-            `Add a matching fileMap entry for this file path, or mark this import as external.`,
+          `Import "${displaySpecifier}" in ${transformed.resolvedPath}, resolved to "${resolvedImport.identityPath}", is outside all configured mounts. ` +
+            `Add a matching mount for this file path, or mark this import as external.`,
           {
-            code: 'IMPORT_OUTSIDE_FILE_MAP',
+            code: 'IMPORT_OUTSIDE_MOUNTS',
           },
         ),
         trackedFiles,
@@ -200,6 +216,7 @@ export async function resolveModule(
     }
 
     deps.add(resolvedImport.identityPath)
+    if (!unresolved.dynamic) staticDeps.add(resolvedImport.identityPath)
 
     if (transformed.packageSpecifiers.includes(unresolved.specifier)) {
       let packageJsonPath =
@@ -216,12 +233,50 @@ export async function resolveModule(
       })
     }
 
-    importsWithPaths.push({
+    let imported: ResolvedImport = {
+      compiledSpecifier: unresolved.specifier,
       depPath: resolvedImport.identityPath,
       end: unresolved.end,
       quote: unresolved.quote,
+      specifier: displaySpecifier,
       start: unresolved.start,
-    })
+    }
+    importsWithPaths.push(imported)
+
+    if (isBareImportSpecifier(displaySpecifier)) {
+      pendingBareImportScopes.push({
+        imported,
+        resolvedIdentityPath: resolvedImport.identityPath,
+        specifier: normalizeSpecifierResolution(unresolved.specifier, transformed.resolvedPath)
+          .specifier,
+        trackedResolution,
+      })
+    }
+  }
+
+  if (pendingBareImportScopes.length > 0) {
+    let scopeResults = await resolveBareImportScopes(
+      pendingBareImportScopes,
+      transformed.resolvedPath,
+      args,
+    )
+    for (let index = 0; index < scopeResults.length; index++) {
+      let result = scopeResults[index]
+      let pending = pendingBareImportScopes[index]
+      if (!result.ok) {
+        return failResolve(
+          result.error,
+          trackedFiles,
+          trackedResolutions,
+          transformed.resolvedPath,
+          {
+            isWatchIgnored: args.isWatchIgnored,
+            trackedResolution: pending.trackedResolution,
+          },
+        )
+      }
+      pending.imported.scopePathname = result.scopePathname
+    }
   }
 
   for (let unresolved of transformed.hmr.acceptedDeps) {
@@ -254,7 +309,7 @@ export async function resolveModule(
       return failResolve(
         createAssetServerCompilationError(
           `Failed to resolve accepted HMR dependency "${displaySpecifier}" in ${transformed.resolvedPath}. ` +
-            `Ensure it resolves to a file within the configured asset server fileMap, or mark it as external.`,
+            `Ensure it resolves to a file within a configured asset server mount, or mark it as external.`,
           {
             code: 'IMPORT_RESOLUTION_FAILED',
           },
@@ -303,10 +358,10 @@ export async function resolveModule(
     if (!stableUrlPathname) {
       return failResolve(
         createAssetServerCompilationError(
-          `Accepted HMR dependency "${displaySpecifier}" in ${transformed.resolvedPath}, resolved to "${resolvedImport.identityPath}", is outside all configured fileMap entries. ` +
-            `Add a matching fileMap entry for this file path, or mark this import as external.`,
+          `Accepted HMR dependency "${displaySpecifier}" in ${transformed.resolvedPath}, resolved to "${resolvedImport.identityPath}", is outside all configured mounts. ` +
+            `Add a matching mount for this file path, or mark this import as external.`,
           {
-            code: 'IMPORT_OUTSIDE_FILE_MAP',
+            code: 'IMPORT_OUTSIDE_MOUNTS',
           },
         ),
         trackedFiles,
@@ -324,9 +379,11 @@ export async function resolveModule(
     }
 
     acceptedDepsWithPaths.push({
+      compiledSpecifier: unresolved.specifier,
       depPath: resolvedImport.identityPath,
       end: unresolved.end,
       quote: unresolved.quote,
+      specifier: displaySpecifier,
       start: unresolved.start,
     })
   }
@@ -336,7 +393,6 @@ export async function resolveModule(
     tracking: toResolveTracking(trackedFiles, trackedResolutions),
     value: {
       deps: [...deps],
-      fingerprint: transformed.fingerprint,
       hmr: {
         acceptedDeps: acceptedDepsWithPaths,
         selfAccepting: transformed.hmr.selfAccepting,
@@ -348,11 +404,117 @@ export async function resolveModule(
       rawCode: transformed.rawCode,
       resolvedPath: transformed.resolvedPath,
       sourceMap: transformed.sourceMap,
+      staticDeps: [...staticDeps],
       stableUrlPathname: transformed.stableUrlPathname,
     },
   }
 }
 
+async function resolveBareImportScopes(
+  pendingScopes: PendingBareImportScope[],
+  importerPath: string,
+  args: ResolveArgs,
+): Promise<
+  ({ ok: true; scopePathname: string } | { ok: false; error: AssetServerCompilationError })[]
+> {
+  let results = new Array<
+    { ok: true; scopePathname: string } | { ok: false; error: AssetServerCompilationError }
+  >(pendingScopes.length)
+  let nextIndex = 0
+
+  async function worker(): Promise<void> {
+    while (nextIndex < pendingScopes.length) {
+      let index = nextIndex++
+      let pending = pendingScopes[index]
+      try {
+        results[index] = {
+          ok: true,
+          scopePathname: await getBareImportScopePathname({
+            importerPath,
+            resolvedIdentityPath: pending.resolvedIdentityPath,
+            specifier: pending.specifier,
+            ...args,
+          }),
+        }
+      } catch (error) {
+        results[index] = {
+          ok: false,
+          error: isAssetServerCompilationError(error)
+            ? error
+            : createAssetServerCompilationError(
+                `Failed to determine an import map scope for "${pending.imported.specifier}" in ${importerPath}. ${formatUnknownError(error)}`,
+                { cause: error, code: 'IMPORT_RESOLUTION_FAILED' },
+              ),
+        }
+      }
+    }
+  }
+
+  if (pendingScopes.length === 1) {
+    await worker()
+  } else {
+    await Promise.all(
+      Array.from({ length: Math.min(args.concurrency, pendingScopes.length) }, () => worker()),
+    )
+  }
+  return results
+}
+
+async function getBareImportScopePathname(args: {
+  importerPath: string
+  isDirectoryResolutionFileIndependent(directory: string): boolean
+  resolvedIdentityPath: string
+  resolveDirectorySpecifierIdentity(directory: string, specifier: string): Promise<string | null>
+  routes: CompiledRoutes
+  specifier: string
+}): Promise<string> {
+  let importerDirectory = normalizeFilePath(path.dirname(args.importerPath))
+  let importerScopePathname = args.routes.toUrlPathname(importerDirectory)
+  if (!importerScopePathname) {
+    throw new Error(`Expected a URL pathname for ${importerDirectory}`)
+  }
+
+  let importerDirectoryResolution: string | null = args.resolvedIdentityPath
+  if (!args.isDirectoryResolutionFileIndependent(importerDirectory)) {
+    importerDirectoryResolution = await args.resolveDirectorySpecifierIdentity(
+      importerDirectory,
+      args.specifier,
+    )
+    if (importerDirectoryResolution !== args.resolvedIdentityPath) {
+      throw createAssetServerCompilationError(
+        `Bare import "${args.specifier}" in ${args.importerPath} resolves differently based on the importer file. ` +
+          `Browser module resolution must be uniform for all files in the same directory.`,
+        { code: 'IMPORT_RESOLUTION_NOT_DIRECTORY_UNIFORM' },
+      )
+    }
+  }
+
+  let directory = importerDirectory
+  let scopePathname = importerScopePathname
+  let broadestScopePathname = importerScopePathname
+  while (true) {
+    let resolvedIdentityPath =
+      directory === importerDirectory
+        ? importerDirectoryResolution
+        : await args.resolveDirectorySpecifierIdentity(directory, args.specifier)
+    if (resolvedIdentityPath !== args.resolvedIdentityPath) break
+
+    broadestScopePathname = scopePathname
+    let parentDirectory = normalizeFilePath(path.dirname(directory))
+    if (parentDirectory === directory) break
+    let parentScopePathname = args.routes.toUrlPathname(parentDirectory)
+    if (!parentScopePathname) break
+    directory = parentDirectory
+    scopePathname = parentScopePathname
+  }
+
+  return ensureTrailingSlash(broadestScopePathname)
+}
+
+function ensureTrailingSlash(value: string): string {
+  return value.endsWith('/') ? value : `${value}/`
+}
+
 function findNearestPackageJsonPath(filePath: string): string | null {
   let directory = path.dirname(filePath)
 
@@ -462,7 +624,7 @@ async function batchResolveSpecifiers(
           normalizedResolution.importerPath === getInjectedPackageImporterPath()
             ? `Failed to resolve injected import "${specifier}" from asset server.`
             : `Failed to resolve import "${normalizedResolution.specifier}" in ${normalizedResolution.importerPath}. ` +
-                `Ensure it resolves to a file within the configured asset server fileMap, or mark it as external.`,
+                `Ensure it resolves to a file within a configured asset server mount, or mark it as external.`,
           {
             code: 'IMPORT_RESOLUTION_FAILED',
           },

package/src/lib/scripts/specifiers.ts

@@ -0,0 +1,11 @@
+export function isBareImportSpecifier(specifier: string): boolean {
+  return (
+    !specifier.startsWith('./') &&
+    !specifier.startsWith('../') &&
+    !specifier.startsWith('/') &&
+    !specifier.startsWith('file:') &&
+    !specifier.startsWith('data:') &&
+    !specifier.startsWith('http://') &&
+    !specifier.startsWith('https://')
+  )
+}

package/src/lib/scripts/transform.ts

@@ -18,7 +18,6 @@ import {
   isAssetServerCompilationError,
 } from '../compilation-error.ts'
 import type { AssetServerCompilationError } from '../compilation-error.ts'
-import { generateFingerprint } from '../fingerprint.ts'
 import {
   maskAuthoredInjectedPackageSpecifier,
   mayContainInjectedPackageSpecifier,
@@ -38,6 +37,7 @@ import type { EmittedModule } from './emit.ts'
 import type { ResolvedScriptTarget } from '../target.ts'
 import type { ResolvedModule } from './resolve.ts'
 import { scriptLoaderConditions } from './conditions.ts'
+import { isBareImportSpecifier } from './specifiers.ts'
 
 type ScriptRecord = ModuleRecord<TransformedModule, ResolvedModule, EmittedModule>
 
@@ -74,16 +74,16 @@ export type ResolveModuleResult = {
 }
 
 type UnresolvedImport = {
+  dynamic: boolean
   end: number
   quote?: '"' | "'" | '`'
   specifier: string
   start: number
 }
 
-type HmrAcceptedDependency = UnresolvedImport
+type HmrAcceptedDependency = Omit<UnresolvedImport, 'dynamic'>
 
 export type TransformedModule = {
-  fingerprint: string | null
   hmr: {
     acceptedDeps: HmrAcceptedDependency[]
     selfAccepting: boolean
@@ -121,7 +121,6 @@ type TsconfigTransformOptions = {
 type TsconfigTransformOptionsResolver = ReturnType<typeof createTsconfigTransformOptionsResolver>
 
 export type TransformArgs = {
-  buildId: string | null
   define: Record<string, string> | null
   externalSet: ReadonlySet<string>
   isWatchIgnored(filePath: string): boolean
@@ -225,9 +224,9 @@ export async function transformModule(
     let stableUrlPathname = args.routes.toUrlPathname(record.identityPath)
     if (!stableUrlPathname) {
       throw createAssetServerCompilationError(
-        `File ${record.identityPath} is outside all configured fileMap entries.`,
+        `File ${record.identityPath} is outside all configured mounts.`,
         {
-          code: 'FILE_OUTSIDE_FILE_MAP',
+          code: 'FILE_OUTSIDE_MOUNTS',
         },
       )
     }
@@ -272,13 +271,6 @@ export async function transformModule(
         trackedFiles,
       },
       value: {
-        fingerprint:
-          args.buildId === null
-            ? null
-            : await generateFingerprint({
-                buildId: args.buildId,
-                content: sourceText,
-              }),
         hmr: getHmrAnalysis(analysis.rawCode),
         identityPath: record.identityPath,
         importerDir: path.dirname(resolvedPath),
@@ -434,18 +426,6 @@ function findNearestTsconfigPath(directory: string): string | null {
   }
 }
 
-function isBareImportSpecifier(specifier: string): boolean {
-  return (
-    !specifier.startsWith('./') &&
-    !specifier.startsWith('../') &&
-    !specifier.startsWith('/') &&
-    !specifier.startsWith('file:') &&
-    !specifier.startsWith('data:') &&
-    !specifier.startsWith('http://') &&
-    !specifier.startsWith('https://')
-  )
-}
-
 async function analyzeModuleSource(
   sourceText: string,
   resolvedPath: string,
@@ -823,6 +803,7 @@ async function getUnresolvedImportsFromLexer(rawCode: string): Promise<Unresolve
     let specifier = getStaticImportSpecifier(rawCode, imported)
     if (specifier == null || isBrowserExternalModuleUrl(specifier)) continue
     unresolvedImports.push({
+      dynamic: imported.d !== -1,
       specifier,
       start: imported.s,
       end: imported.e,