wip

Author: eryue0220

server/api/registry/file/[...pkg].get.ts

@@ -1,4 +1,5 @@
 import * as v from 'valibot'
+import type { InternalImportsMap } from '#server/utils/import-resolver'
 import { PackageFileQuerySchema } from '#shared/schemas/package'
 import type { ReadmeResponse } from '#shared/types/readme'
 import {
@@ -27,6 +28,7 @@ interface PackageJson {
   devDependencies?: Record<string, string>
   peerDependencies?: Record<string, string>
   optionalDependencies?: Record<string, string>
+  imports?: InternalImportsMap
 }
 
 /**
@@ -159,7 +161,13 @@ export default defineCachedEventHandler(
         // Create resolver for relative imports
         if (fileTreeResponse) {
           const files = flattenFileTree(fileTreeResponse.tree)
-          resolveRelative = createImportResolver(files, filePath, packageName, version)
+          resolveRelative = createImportResolver(
+            files,
+            filePath,
+            packageName,
+            version,
+            pkgJson?.imports,
+          )
         }
       }
 
@@ -200,6 +208,7 @@ export default defineCachedEventHandler(
   {
     // File content for a specific version never changes - cache permanently
     maxAge: CACHE_MAX_AGE_ONE_YEAR, // 1 year
+    shouldBypassCache: () => import.meta.dev,
     getKey: event => {
       const pkg = getRouterParam(event, 'pkg') ?? ''
       return `file:v${CACHE_VERSION}:${pkg.replace(/\/+$/, '').trim()}`

server/utils/code-highlight.ts

@@ -178,6 +178,10 @@ export function linkifyModuleSpecifiers(html: string, options?: LinkifyOptions):
       return resolveRelative(moduleSpecifier)
     }
 
+    if ((cleanSpec.startsWith('#') || cleanSpec.startsWith('~')) && resolveRelative) {
+      return resolveRelative(moduleSpecifier)
+    }
+
     // Not a relative import - check if it's an npm package
     if (!isNpmPackage(moduleSpecifier)) {
       return null

server/utils/import-resolver.ts

@@ -133,6 +133,10 @@ export interface ResolvedImport {
   path: string
 }
 
+export type InternalImportTarget = string | { default?: string; import?: string } | null | undefined
+
+export type InternalImportsMap = Record<string, InternalImportTarget>
+
 /**
  * Resolve a relative import specifier to an actual file path.
  *
@@ -200,6 +204,55 @@ export function resolveRelativeImport(
   return null
 }
 
+function normalizeInternalImportTarget(target: InternalImportTarget): string | null {
+  if (typeof target === 'string') {
+    return target
+  }
+
+  if (target && typeof target === 'object') {
+    if (typeof target.import === 'string') {
+      return target.import
+    }
+
+    if (typeof target.default === 'string') {
+      return target.default
+    }
+  }
+
+  return null
+}
+
+/**
+ * import ... from '#components/Button.vue'
+ * import ... from '#/components/Button.vue'
+ * import ... from '~/components/Button.vue'
+ * import ... from '~components/Button.vue'
+ */
+export function resolveInternalImport(
+  specifier: string,
+  imports: InternalImportsMap | undefined,
+  files: FileSet,
+): ResolvedImport | null {
+  const cleanSpecifier = specifier.replace(/^['"]|['"]$/g, '').trim()
+
+  if ((!cleanSpecifier.startsWith('#') && !cleanSpecifier.startsWith('~')) || !imports) {
+    return null
+  }
+
+  const target = normalizeInternalImportTarget(imports[cleanSpecifier])
+  console.log('resolved internal import', imports, cleanSpecifier, target)
+  if (!target || !target.startsWith('./')) {
+    return null
+  }
+
+  const path = normalizePath(target)
+  if (!path || path.startsWith('..') || !files.has(path)) {
+    return null
+  }
+
+  return { path }
+}
+
 /**
  * Create a resolver function bound to a specific file tree and current file.
  */
@@ -208,9 +261,13 @@ export function createImportResolver(
   currentFile: string,
   packageName: string,
   version: string,
+  internalImports?: InternalImportsMap,
 ): (specifier: string) => string | null {
   return (specifier: string) => {
-    const resolved = resolveRelativeImport(specifier, currentFile, files)
+    const relativeResolved = resolveRelativeImport(specifier, currentFile, files)
+    const internalResolved = resolveInternalImport(specifier, internalImports, files)
+    const resolved = relativeResolved ?? internalResolved
+
     if (resolved) {
       return `/package-code/${packageName}/v/${version}/${resolved.path}`
     }

test/unit/server/utils/import-resolver.spec.ts

@@ -3,6 +3,7 @@ import type { PackageFileTree } from '../../../../shared/types'
 import {
   createImportResolver,
   flattenFileTree,
+  resolveInternalImport,
   resolveRelativeImport,
 } from '../../../../server/utils/import-resolver'
 
@@ -177,4 +178,73 @@ describe('createImportResolver', () => {
 
     expect(url).toBe('/package-code/@scope/pkg/v/1.2.3/dist/utils.js')
   })
+
+  it('resolves package imports aliases to code browser URLs', () => {
+    const files = new Set<string>(['dist/app/nuxt.js'])
+    const resolver = createImportResolver(files, 'dist/index.js', 'nuxt', '4.3.1', {
+      '#app/nuxt': './dist/app/nuxt.js',
+    })
+
+    const url = resolver('#app/nuxt')
+
+    expect(url).toBe('/package-code/nuxt/v/4.3.1/dist/app/nuxt.js')
+  })
+})
+
+describe('resolveInternalSpecifier', () => {
+  it('resolves exact imports map matches to files in the package', () => {
+    const files = new Set<string>(['dist/app/nuxt.js'])
+
+    const resolved = resolveInternalImport(
+      '#app/nuxt',
+      {
+        '#app/nuxt': './dist/app/nuxt.js',
+      },
+      files,
+    )
+
+    expect(resolved?.path).toBe('dist/app/nuxt.js')
+  })
+
+  it('supports import condition objects', () => {
+    const files = new Set<string>(['dist/app/nuxt.js'])
+
+    const resolved = resolveInternalImport(
+      '#app/nuxt',
+      {
+        '#app/nuxt': { import: './dist/app/nuxt.js' },
+      },
+      files,
+    )
+
+    expect(resolved?.path).toBe('dist/app/nuxt.js')
+  })
+
+  it('returns null when the target file does not exist', () => {
+    const files = new Set<string>(['dist/app/index.js'])
+
+    const resolved = resolveInternalImport(
+      '#app/nuxt',
+      {
+        '#app/nuxt': './dist/app/nuxt.js',
+      },
+      files,
+    )
+
+    expect(resolved).toBeNull()
+  })
+
+  it('returns null for unknown internal specifiers', () => {
+    const files = new Set<string>(['dist/app/nuxt.js'])
+
+    const resolved = resolveInternalImport(
+      '#app/nuxt',
+      {
+        '#app': './dist/app/index.js',
+      },
+      files,
+    )
+
+    expect(resolved).toBeNull()
+  })
 })