Optimize

Author: owjs3901

bun.lock

@@ -90,12 +90,13 @@
     "typescript": "5.9.3"
   },
   "devDependencies": {
-    "eslint-plugin-devup": "^2.0.17",
-    "husky": "^9.1.7",
-    "oxlint": "^1.55",
+    "@types/bun": "^1.3.10",
     "@types/node": "25.5.0",
     "@types/vscode": "1.110.0",
     "@vscode/vsce": "3.7.1",
-    "globals": "17.4.0"
+    "eslint-plugin-devup": "^2.0.17",
+    "globals": "17.4.0",
+    "husky": "^9.1.7",
+    "oxlint": "^1.55"
   }
 }

package.json

@@ -51,26 +51,25 @@ export class ComponentLensAnalyzer {
     this.resolver.clear()
   }
 
-  public analyzeDocument(
+  public invalidateFile(filePath: string): void {
+    this.analysisCache.delete(filePath)
+  }
+
+  public async analyzeDocument(
     filePath: string,
     sourceText: string,
     signature: string,
-  ): ComponentUsage[] {
+  ): Promise<ComponentUsage[]> {
     const analysis = this.getAnalysis(filePath, sourceText, signature)
     if (!analysis) {
       return []
     }
 
-    const usages: ComponentUsage[] = []
+    const tagResolutions = new Map<JsxTagReference, string>()
+    const uniqueFilePaths = new Set<string>()
 
     for (const jsxTag of analysis.jsxTags) {
       if (analysis.localComponentNames.has(jsxTag.lookupName)) {
-        usages.push({
-          kind: analysis.ownComponentKind,
-          ranges: jsxTag.ranges,
-          sourceFilePath: filePath,
-          tagName: jsxTag.tagName,
-        })
         continue
       }
 
@@ -87,8 +86,40 @@ export class ComponentLensAnalyzer {
         continue
       }
 
-      const componentKind = this.getFileComponentKind(resolvedFilePath)
-      if (componentKind === 'unknown') {
+      tagResolutions.set(jsxTag, resolvedFilePath)
+      uniqueFilePaths.add(resolvedFilePath)
+    }
+
+    const componentKinds = new Map<string, ComponentKind>()
+    await Promise.all(
+      [...uniqueFilePaths].map(async (resolvedPath) => {
+        componentKinds.set(
+          resolvedPath,
+          await this.getFileComponentKind(resolvedPath),
+        )
+      }),
+    )
+
+    const usages: ComponentUsage[] = []
+
+    for (const jsxTag of analysis.jsxTags) {
+      if (analysis.localComponentNames.has(jsxTag.lookupName)) {
+        usages.push({
+          kind: analysis.ownComponentKind,
+          ranges: jsxTag.ranges,
+          sourceFilePath: filePath,
+          tagName: jsxTag.tagName,
+        })
+        continue
+      }
+
+      const resolvedFilePath = tagResolutions.get(jsxTag)
+      if (!resolvedFilePath) {
+        continue
+      }
+
+      const componentKind = componentKinds.get(resolvedFilePath)
+      if (!componentKind || componentKind === 'unknown') {
         continue
       }
 
@@ -103,9 +134,15 @@ export class ComponentLensAnalyzer {
     return usages
   }
 
-  private getFileComponentKind(filePath: string): ComponentKind {
-    const sourceText = this.host.readFile(filePath)
-    const signature = this.host.getSignature(filePath)
+  private async getFileComponentKind(filePath: string): Promise<ComponentKind> {
+    const [sourceText, signature] = await Promise.all([
+      this.host.readFileAsync
+        ? this.host.readFileAsync(filePath)
+        : this.host.readFile(filePath),
+      this.host.getSignatureAsync
+        ? this.host.getSignatureAsync(filePath)
+        : this.host.getSignature(filePath),
+    ])
     if (sourceText === undefined || signature === undefined) {
       return 'unknown'
     }
@@ -253,8 +290,16 @@ function hasUseClientDirective(sourceFile: ts.SourceFile): boolean {
   return false
 }
 
+const COMPONENT_NAME_RE = /^[A-Z]/u
+const COMPONENT_WRAPPER_NAMES = new Set([
+  'forwardRef',
+  'memo',
+  'React.forwardRef',
+  'React.memo',
+])
+
 function isComponentIdentifier(name: string): boolean {
-  return /^[A-Z]/u.test(name)
+  return COMPONENT_NAME_RE.test(name)
 }
 
 function isComponentInitializer(
@@ -277,11 +322,7 @@ function isComponentInitializer(
   }
 
   const calleeName = initializer.expression.getText()
-  if (
-    !['forwardRef', 'memo', 'React.forwardRef', 'React.memo'].includes(
-      calleeName,
-    )
-  ) {
+  if (!COMPONENT_WRAPPER_NAMES.has(calleeName)) {
     return false
   }
 

src/analyzer.ts

@@ -15,49 +15,47 @@ const DEFAULT_HIGHLIGHT_COLORS: HighlightColors = {
 }
 
 export function activate(context: vscode.ExtensionContext): void {
-  const initialConfiguration = getConfiguration()
+  let config = getConfiguration()
   const sourceHost = new WorkspaceSourceHost()
   const resolver = new ImportResolver(sourceHost)
   const analyzer = new ComponentLensAnalyzer(sourceHost, resolver)
-  const decorations = new LensDecorations(initialConfiguration.highlightColors)
+  const decorations = new LensDecorations(config.highlightColors)
 
   context.subscriptions.push(decorations)
 
   let refreshTimer: NodeJS.Timeout | undefined
   let watcherDisposables: vscode.Disposable[] = []
 
-  const clearCachesAndRefresh = (
-    delay = getConfiguration().debounceMs,
-  ): void => {
+  const clearCachesAndRefresh = (delay = config.debounceMs): void => {
     analyzer.clear()
     scheduleRefresh(delay)
   }
 
-  const refreshVisibleEditors = (): void => {
-    for (const editor of vscode.window.visibleTextEditors) {
-      refreshEditor(editor)
-    }
+  const refreshVisibleEditors = async (): Promise<void> => {
+    await Promise.all(
+      vscode.window.visibleTextEditors.map((editor) => refreshEditor(editor)),
+    )
   }
 
-  const scheduleRefresh = (delay = getConfiguration().debounceMs): void => {
+  const scheduleRefresh = (delay = config.debounceMs): void => {
     if (refreshTimer) {
       clearTimeout(refreshTimer)
     }
 
     refreshTimer = setTimeout(() => {
       refreshTimer = undefined
-      refreshVisibleEditors()
+      void refreshVisibleEditors()
     }, delay)
   }
 
-  const refreshEditor = (editor: vscode.TextEditor): void => {
-    if (!getConfiguration().enabled || !isSupportedDocument(editor.document)) {
+  const refreshEditor = async (editor: vscode.TextEditor): Promise<void> => {
+    if (!config.enabled || !isSupportedDocument(editor.document)) {
       decorations.clear(editor)
       return
     }
 
     const signature = createOpenSignature(editor.document.version)
-    const usages = analyzer.analyzeDocument(
+    const usages = await analyzer.analyzeDocument(
       editor.document.fileName,
       editor.document.getText(),
       signature,
@@ -99,9 +97,9 @@ export function activate(context: vscode.ExtensionContext): void {
   }
 
   context.subscriptions.push(
-    vscode.commands.registerCommand('reactComponentLens.refresh', () => {
+    vscode.commands.registerCommand('reactComponentLens.refresh', async () => {
       analyzer.clear()
-      refreshVisibleEditors()
+      await refreshVisibleEditors()
       void vscode.window.showInformationMessage(
         'React Component Lens refreshed.',
       )
@@ -114,14 +112,17 @@ export function activate(context: vscode.ExtensionContext): void {
     vscode.window.onDidChangeVisibleTextEditors(() => {
       scheduleRefresh(0)
     }),
-    vscode.workspace.onDidChangeTextDocument(() => {
-      clearCachesAndRefresh()
+    vscode.workspace.onDidChangeTextDocument((event) => {
+      analyzer.invalidateFile(event.document.fileName)
+      scheduleRefresh()
     }),
-    vscode.workspace.onDidOpenTextDocument(() => {
-      clearCachesAndRefresh()
+    vscode.workspace.onDidOpenTextDocument((document) => {
+      analyzer.invalidateFile(document.fileName)
+      scheduleRefresh()
     }),
-    vscode.workspace.onDidSaveTextDocument(() => {
-      clearCachesAndRefresh(0)
+    vscode.workspace.onDidSaveTextDocument((document) => {
+      analyzer.invalidateFile(document.fileName)
+      scheduleRefresh(0)
     }),
     vscode.workspace.onDidChangeWorkspaceFolders(() => {
       analyzer.clear()
@@ -133,8 +134,10 @@ export function activate(context: vscode.ExtensionContext): void {
         return
       }
 
+      config = getConfiguration()
+
       if (event.affectsConfiguration('reactComponentLens.highlightColors')) {
-        decorations.updateColors(getConfiguration().highlightColors)
+        decorations.updateColors(config.highlightColors)
       }
 
       scheduleRefresh(0)
@@ -202,12 +205,12 @@ class WorkspaceSourceHost implements SourceHost {
       return createOpenSignature(openDocument.version)
     }
 
-    if (!fs.existsSync(filePath)) {
+    try {
+      const stats = fs.statSync(filePath)
+      return createDiskSignature(stats.mtimeMs, stats.size)
+    } catch {
       return undefined
     }
-
-    const stats = fs.statSync(filePath)
-    return createDiskSignature(stats.mtimeMs, stats.size)
   }
 
   public readFile(filePath: string): string | undefined {
@@ -216,11 +219,40 @@ class WorkspaceSourceHost implements SourceHost {
       return openDocument.getText()
     }
 
-    if (!fs.existsSync(filePath)) {
+    try {
+      return fs.readFileSync(filePath, 'utf8')
+    } catch {
+      return undefined
+    }
+  }
+
+  public async readFileAsync(filePath: string): Promise<string | undefined> {
+    const openDocument = this.getOpenDocument(filePath)
+    if (openDocument) {
+      return openDocument.getText()
+    }
+
+    try {
+      return await fs.promises.readFile(filePath, 'utf8')
+    } catch {
       return undefined
     }
+  }
 
-    return fs.readFileSync(filePath, 'utf8')
+  public async getSignatureAsync(
+    filePath: string,
+  ): Promise<string | undefined> {
+    const openDocument = this.getOpenDocument(filePath)
+    if (openDocument) {
+      return createOpenSignature(openDocument.version)
+    }
+
+    try {
+      const stats = await fs.promises.stat(filePath)
+      return createDiskSignature(stats.mtimeMs, stats.size)
+    } catch {
+      return undefined
+    }
   }
 
   private getOpenDocument(filePath: string): vscode.TextDocument | undefined {

src/extension.ts

@@ -6,6 +6,8 @@ export interface SourceHost {
   fileExists(filePath: string): boolean
   getSignature(filePath: string): string | undefined
   readFile(filePath: string): string | undefined
+  getSignatureAsync?(filePath: string): Promise<string | undefined>
+  readFileAsync?(filePath: string): Promise<string | undefined>
 }
 
 const DEFAULT_COMPILER_OPTIONS: ts.CompilerOptions = {