@remix-run/assets 0.1.0 → 0.3.0

package/src/lib/scripts/transform.ts

@@ -2,10 +2,13 @@ import * as fs from 'node:fs'
 import * as fsp from 'node:fs/promises'
 import * as path from 'node:path'
 import { getTsconfig } from 'get-tsconfig'
+import MagicString from 'magic-string'
 import { minify } from 'oxc-minify'
+import { parseSync, visitorKeys } from 'oxc-parser'
 import { transform as oxcTransform } from 'oxc-transform'
 import { init as esModuleLexerInit, parse as esModuleLexer } from 'es-module-lexer'
 import type { Cache, TsConfigJsonResolved } from 'get-tsconfig'
+import type { Node, Program } from 'oxc-parser'
 import type { TransformOptions as OxcTransformOptions } from 'oxc-transform'
 
 import { isCommonJS, mayContainCommonJSModuleGlobals } from './cjs-check.ts'
@@ -15,11 +18,20 @@ import {
 } from '../compilation-error.ts'
 import type { AssetServerCompilationError } from '../compilation-error.ts'
 import { generateFingerprint } from '../fingerprint.ts'
+import {
+  maskAuthoredInjectedPackageSpecifier,
+  mayContainInjectedPackageSpecifier,
+  restoreAuthoredInjectedPackageSpecifier,
+} from '../injected-packages.ts'
+import type { ModuleRecord, ModuleTracking } from '../module-store.ts'
 import { normalizeFilePath } from '../paths.ts'
 import type { CompiledRoutes } from '../routes.ts'
-import type { ScriptsTarget } from '../asset-server.ts'
-import type { ModuleRecord } from './store.ts'
 import { composeSourceMaps, rewriteSourceMapSources, stringifySourceMap } from '../source-maps.ts'
+import type { EmittedModule } from './emit.ts'
+import type { ResolvedScriptTarget } from '../target.ts'
+import type { ResolvedModule } from './resolve.ts'
+
+type ScriptRecord = ModuleRecord<TransformedModule, ResolvedModule, EmittedModule>
 
 type SourceLanguage = 'js' | 'jsx' | 'ts' | 'tsx'
 
@@ -72,19 +84,18 @@ export type TransformedModule = {
   unresolvedImports: UnresolvedImport[]
 }
 
-export type TransformFailureState = {
-  trackedFiles: readonly string[]
-}
-
-type TransformResult =
+type TransformResult = {
+  tracking: ModuleTracking
+} & (
   | {
       ok: true
       value: TransformedModule
     }
-  | ({
+  | {
       ok: false
       error: AssetServerCompilationError
-    } & TransformFailureState)
+    }
+)
 
 type TsconfigTransformOptions = {
   trackedFiles: string[]
@@ -103,7 +114,7 @@ export type TransformArgs = {
   routes: CompiledRoutes
   sourceMapSourcePaths: 'absolute' | 'url'
   sourceMaps: 'external' | 'inline' | null
-  target: ScriptsTarget | null
+  target: ResolvedScriptTarget | null
   tsconfigTransformOptionsResolver: TsconfigTransformOptionsResolver
 }
 
@@ -144,17 +155,19 @@ export function createTsconfigTransformOptionsResolver() {
 }
 
 export async function transformModule(
-  record: ModuleRecord,
+  record: ScriptRecord,
   args: TransformArgs,
 ): Promise<TransformResult> {
   let resolvedPath = args.resolveActualPath(record.identityPath)
   if (!resolvedPath) {
     return {
       ok: false,
-      error: createAssetServerCompilationError(`Module not found: ${record.identityPath}`, {
-        code: 'MODULE_NOT_FOUND',
+      error: createAssetServerCompilationError(`File not found: ${record.identityPath}`, {
+        code: 'FILE_NOT_FOUND',
       }),
-      trackedFiles: args.isWatchIgnored(record.identityPath) ? [] : [record.identityPath],
+      tracking: {
+        trackedFiles: args.isWatchIgnored(record.identityPath) ? [] : [record.identityPath],
+      },
     }
   }
 
@@ -173,17 +186,21 @@ export async function transformModule(
     if (isNoEntityError(error)) {
       return {
         ok: false,
-        error: createAssetServerCompilationError(`Module not found: ${resolvedPath}`, {
+        error: createAssetServerCompilationError(`File not found: ${resolvedPath}`, {
           cause: error,
-          code: 'MODULE_NOT_FOUND',
+          code: 'FILE_NOT_FOUND',
         }),
-        trackedFiles,
+        tracking: {
+          trackedFiles,
+        },
       }
     }
     return {
       ok: false,
       error: toTransformFailedError(error, resolvedPath),
-      trackedFiles,
+      tracking: {
+        trackedFiles,
+      },
     }
   }
 
@@ -196,7 +213,7 @@ export async function transformModule(
     })
 
     analysis.unresolvedImports = analysis.unresolvedImports.filter(
-      (unresolved) => !args.externalSet.has(unresolved.specifier),
+      (unresolved) => !args.externalSet.has(getDisplayImportSpecifier(unresolved.specifier)),
     )
 
     if (mayContainCommonJSModuleGlobals(sourceText) && isCommonJS(analysis.rawCode)) {
@@ -205,7 +222,7 @@ export async function transformModule(
           `This module uses CommonJS (require/module.exports) which is not supported. ` +
           `Please use an ESM-compatible module.`,
         {
-          code: 'MODULE_COMMONJS_NOT_SUPPORTED',
+          code: 'COMMONJS_NOT_SUPPORTED',
         },
       )
     }
@@ -213,9 +230,9 @@ export async function transformModule(
     let stableUrlPathname = args.routes.toUrlPathname(record.identityPath)
     if (!stableUrlPathname) {
       throw createAssetServerCompilationError(
-        `Module ${record.identityPath} is outside all configured fileMap entries.`,
+        `File ${record.identityPath} is outside all configured fileMap entries.`,
         {
-          code: 'MODULE_OUTSIDE_FILE_MAP',
+          code: 'FILE_OUTSIDE_FILE_MAP',
         },
       )
     }
@@ -226,11 +243,15 @@ export async function transformModule(
           resolvedPath,
           stableUrlPathname,
           args.sourceMapSourcePaths,
+          sourceText,
         )
       : null
 
     return {
       ok: true,
+      tracking: {
+        trackedFiles,
+      },
       value: {
         fingerprint:
           args.buildId === null
@@ -256,7 +277,9 @@ export async function transformModule(
     return {
       ok: false,
       error: toTransformFailedError(error, resolvedPath),
-      trackedFiles,
+      tracking: {
+        trackedFiles,
+      },
     }
   }
 }
@@ -288,24 +311,25 @@ async function analyzeModuleSource(
     define?: Record<string, string>
     minify: boolean
     sourceMaps?: 'external' | 'inline'
-    target?: ScriptsTarget
+    target?: ResolvedScriptTarget
   },
 ) {
+  let maskedSourceText = maskAuthoredInjectedPackageImports(sourceText, resolvedPath)
   let transformResult: { code: string; errors?: Array<{ message?: string }>; map?: unknown }
   try {
     transformResult = await oxcTransform(
       resolvedPath,
-      sourceText,
+      maskedSourceText,
       getTransformOptions(resolvedPath, transformOptions, options),
     )
     assertNoCompilerErrors(transformResult.errors, resolvedPath, 'transform')
   } catch (error) {
     if (isAssetServerCompilationError(error)) throw error
     throw createAssetServerCompilationError(
-      `Failed to transform module ${resolvedPath}. ${formatUnknownError(error)}`,
+      `Failed to transform script ${resolvedPath}. ${formatUnknownError(error)}`,
       {
         cause: error,
-        code: 'MODULE_TRANSFORM_FAILED',
+        code: 'TRANSFORM_FAILED',
       },
     )
   }
@@ -335,7 +359,7 @@ async function analyzeModuleSource(
 async function minifyModule(
   rawCode: string,
   resolvedPath: string,
-  target: string | undefined,
+  target: ResolvedScriptTarget | undefined,
   sourceMaps?: 'external' | 'inline',
 ) {
   try {
@@ -350,10 +374,10 @@ async function minifyModule(
   } catch (error) {
     if (isAssetServerCompilationError(error)) throw error
     throw createAssetServerCompilationError(
-      `Failed to minify module ${resolvedPath}. ${formatUnknownError(error)}`,
+      `Failed to minify script ${resolvedPath}. ${formatUnknownError(error)}`,
       {
         cause: error,
-        code: 'MODULE_TRANSFORM_FAILED',
+        code: 'TRANSFORM_FAILED',
       },
     )
   }
@@ -365,7 +389,7 @@ function getTransformOptions(
   options: {
     define?: Record<string, string>
     sourceMaps?: 'external' | 'inline'
-    target?: string
+    target?: ResolvedScriptTarget
   },
 ): OxcTransformOptions {
   let compilerOptions = transformOptions.tsconfigRaw?.compilerOptions as
@@ -436,7 +460,7 @@ function getJsxOptions(
       `Unsupported tsconfig compilerOptions.jsx = "${jsx}" for ${resolvedPath}. ` +
         `Asset server must compile JSX to browser-runnable JavaScript.`,
       {
-        code: 'MODULE_TRANSFORM_FAILED',
+        code: 'TRANSFORM_FAILED',
       },
     )
   }
@@ -500,9 +524,9 @@ function assertNoCompilerErrors(
   if (!errors || errors.length === 0) return
 
   throw createAssetServerCompilationError(
-    `Failed to ${operation} module ${resolvedPath}. ${errors[0].message ?? 'Unknown error'}`,
+    `Failed to ${operation} script ${resolvedPath}. ${errors[0].message ?? 'Unknown error'}`,
     {
-      code: 'MODULE_TRANSFORM_FAILED',
+      code: 'TRANSFORM_FAILED',
     },
   )
 }
@@ -526,6 +550,99 @@ async function getUnresolvedImportsFromLexer(rawCode: string): Promise<Unresolve
   return unresolvedImports
 }
 
+function getDisplayImportSpecifier(specifier: string): string {
+  return restoreAuthoredInjectedPackageSpecifier(specifier) ?? specifier
+}
+
+function maskAuthoredInjectedPackageImports(sourceText: string, resolvedPath: string): string {
+  if (!mayContainInjectedPackageSpecifier(sourceText)) {
+    return sourceText
+  }
+
+  let parseResult = parseSync(resolvedPath, sourceText, {
+    lang: getSourceLanguageForPath(resolvedPath),
+    sourceType: 'module',
+  })
+  if (parseResult.errors.length > 0) {
+    return sourceText
+  }
+
+  let replacements: Array<{ end: number; specifier: string; start: number }> = []
+
+  walkAst(parseResult.program, (node) => {
+    if (
+      node.type !== 'ImportDeclaration' &&
+      node.type !== 'ExportAllDeclaration' &&
+      node.type !== 'ExportNamedDeclaration' &&
+      node.type !== 'ImportExpression'
+    ) {
+      return
+    }
+
+    let source = 'source' in node ? node.source : null
+    if (!isStringLiteralNode(source)) return
+
+    let maskedSpecifier = maskAuthoredInjectedPackageSpecifier(source.value)
+    if (maskedSpecifier == null) return
+
+    replacements.push({
+      end: source.end - 1,
+      specifier: maskedSpecifier,
+      start: source.start + 1,
+    })
+  })
+
+  if (replacements.length === 0) return sourceText
+
+  let rewrittenSource = new MagicString(sourceText)
+  for (let replacement of replacements) {
+    rewrittenSource.overwrite(replacement.start, replacement.end, replacement.specifier)
+  }
+
+  return rewrittenSource.toString()
+}
+
+function walkAst(node: Program | Node, visit: (node: Program | Node) => void): void {
+  visit(node)
+
+  let keys = visitorKeys[node.type]
+  if (!keys) return
+
+  let walkableNode = node as unknown as Record<string, unknown>
+  for (let key of keys) {
+    let value = walkableNode[key]
+    if (Array.isArray(value)) {
+      for (let child of value) {
+        if (isAstNode(child)) {
+          walkAst(child, visit)
+        }
+      }
+      continue
+    }
+
+    if (isAstNode(value)) {
+      walkAst(value, visit)
+    }
+  }
+}
+
+function isAstNode(value: unknown): value is Node {
+  return typeof value === 'object' && value !== null && 'type' in value
+}
+
+function isStringLiteralNode(node: Node | null | undefined): node is Node & {
+  end: number
+  start: number
+  value: string
+} {
+  return (
+    node?.type === 'Literal' &&
+    typeof node.start === 'number' &&
+    typeof node.end === 'number' &&
+    typeof node.value === 'string'
+  )
+}
+
 function getStaticImportSpecifier(
   source: string,
   imported: ReturnType<typeof esModuleLexer>[0][number],
@@ -579,10 +696,10 @@ function toTransformFailedError(error: unknown, resolvedPath: string): AssetServ
   if (isAssetServerCompilationError(error)) return error
 
   return createAssetServerCompilationError(
-    `Failed to transform module ${resolvedPath}. ${formatUnknownError(error)}`,
+    `Failed to transform script ${resolvedPath}. ${formatUnknownError(error)}`,
     {
       cause: error,
-      code: 'MODULE_TRANSFORM_FAILED',
+      code: 'TRANSFORM_FAILED',
     },
   )
 }

package/src/lib/source-maps.ts

@@ -52,17 +52,24 @@ export function rewriteSourceMapSources(
   resolvedPath: string,
   stableUrlPathname: string,
   sourceMapSourcePaths: 'absolute' | 'url',
+  sourceContent?: string,
 ): string {
-  let json = JSON.parse(sourceMap) as { sources?: string[] }
+  let json = JSON.parse(sourceMap) as { sources?: string[]; sourcesContent?: string[] }
   json.sources = [
     sourceMapSourcePaths === 'absolute' ? normalizeFilePath(resolvedPath) : stableUrlPathname,
   ]
+  if (sourceContent !== undefined) {
+    json.sourcesContent = [sourceContent]
+  }
   return JSON.stringify(json)
 }
 
 export function stringifySourceMap(map: unknown): string | null {
   if (!map) return null
   if (typeof map === 'string') return map
+  if (map instanceof Uint8Array) {
+    return Buffer.from(map).toString('utf8')
+  }
   if (typeof map === 'object' && map !== null) return JSON.stringify(map)
   return String(map)
 }