Optimize

Author: owjs3901

src/analyzer.ts

@@ -135,14 +135,19 @@ export class ComponentLensAnalyzer {
   }
 
   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),
-    ])
+    let sourceText: string | undefined
+    let signature: string | undefined
+
+    if (this.host.readFileAsync) {
+      ;[sourceText, signature] = await Promise.all([
+        this.host.readFileAsync(filePath),
+        this.host.getSignatureAsync!(filePath),
+      ])
+    } else {
+      sourceText = this.host.readFile(filePath)
+      signature = this.host.getSignature(filePath)
+    }
+
     if (sourceText === undefined || signature === undefined) {
       return 'unknown'
     }
@@ -205,14 +210,15 @@ function collectImportBindings(
     return
   }
 
-  const source = statement.moduleSpecifier.text
   const importClause = statement.importClause
   if (!importClause) {
     return
   }
 
+  const binding: ImportBinding = { source: statement.moduleSpecifier.text }
+
   if (importClause.name) {
-    imports.set(importClause.name.text, { source })
+    imports.set(importClause.name.text, binding)
   }
 
   const namedBindings = importClause.namedBindings
@@ -221,12 +227,12 @@ function collectImportBindings(
   }
 
   if (ts.isNamespaceImport(namedBindings)) {
-    imports.set(namedBindings.name.text, { source })
+    imports.set(namedBindings.name.text, binding)
     return
   }
 
   for (const element of namedBindings.elements) {
-    imports.set(element.name.text, { source })
+    imports.set(element.name.text, binding)
   }
 }
 
@@ -332,22 +338,22 @@ function isComponentInitializer(
   )
 }
 
-function collectJsxTags(root: ts.Node): JsxTagReference[] {
+function collectJsxTags(sourceFile: ts.SourceFile): JsxTagReference[] {
   const jsxTags: JsxTagReference[] = []
   const visit = (node: ts.Node): void => {
     if (
       ts.isJsxOpeningElement(node) ||
       ts.isJsxSelfClosingElement(node) ||
       ts.isJsxClosingElement(node)
     ) {
-      const jsxTag = createJsxTagReference(node, node.getSourceFile())
+      const jsxTag = createJsxTagReference(node, sourceFile)
       if (jsxTag) {
         jsxTags.push(jsxTag)
       }
     }
     ts.forEachChild(node, visit)
   }
-  ts.forEachChild(root, visit)
+  ts.forEachChild(sourceFile, visit)
   return jsxTags
 }
 

src/extension.ts

@@ -32,6 +32,7 @@ export function activate(context: vscode.ExtensionContext): void {
   }
 
   const refreshVisibleEditors = async (): Promise<void> => {
+    sourceHost.invalidateDocumentCache()
     await Promise.all(
       vscode.window.visibleTextEditors.map((editor) => refreshEditor(editor)),
     )
@@ -255,11 +256,20 @@ class WorkspaceSourceHost implements SourceHost {
     }
   }
 
+  public invalidateDocumentCache(): void {
+    this.documentCache = undefined
+  }
+
+  private documentCache: Map<string, vscode.TextDocument> | undefined
+
   private getOpenDocument(filePath: string): vscode.TextDocument | undefined {
-    const normalizedPath = path.normalize(filePath)
-    return vscode.workspace.textDocuments.find(
-      (document) => path.normalize(document.fileName) === normalizedPath,
-    )
+    if (!this.documentCache) {
+      this.documentCache = new Map()
+      for (const document of vscode.workspace.textDocuments) {
+        this.documentCache.set(path.normalize(document.fileName), document)
+      }
+    }
+    return this.documentCache.get(path.normalize(filePath))
   }
 }
 

src/resolver.ts

@@ -56,7 +56,7 @@ export class ImportResolver {
     fromFilePath: string,
     specifier: string,
   ): string | undefined {
-    const normalizedFromFilePath = normalizePath(fromFilePath)
+    const normalizedFromFilePath = path.normalize(fromFilePath)
     const cacheKey = `${normalizedFromFilePath}::${specifier}`
     const cached = this.resolutionCache.get(cacheKey)
     if (cached !== undefined || this.resolutionCache.has(cacheKey)) {
@@ -86,7 +86,7 @@ export class ImportResolver {
       return undefined
     }
 
-    const resolvedFilePath = normalizePath(result.resolvedFileName)
+    const resolvedFilePath = path.normalize(result.resolvedFileName)
     this.resolutionCache.set(cacheKey, resolvedFilePath)
     return resolvedFilePath
   }
@@ -137,19 +137,17 @@ export class ImportResolver {
 }
 
 function findNearestConfigFile(startDirectory: string): string | undefined {
-  let currentDirectory = normalizePath(startDirectory)
+  let currentDirectory = path.normalize(startDirectory)
 
   for (;;) {
     for (const configFileName of CONFIG_FILE_NAMES) {
-      const candidatePath = normalizePath(
-        path.join(currentDirectory, configFileName),
-      )
+      const candidatePath = path.join(currentDirectory, configFileName)
       if (ts.sys.fileExists(candidatePath)) {
         return candidatePath
       }
     }
 
-    const parentDirectory = normalizePath(path.dirname(currentDirectory))
+    const parentDirectory = path.dirname(currentDirectory)
     if (parentDirectory === currentDirectory) {
       return undefined
     }
@@ -159,14 +157,9 @@ function findNearestConfigFile(startDirectory: string): string | undefined {
 }
 
 function isSupportedSourceFile(filePath: string): boolean {
-  const normalizedFilePath = normalizePath(filePath)
-  if (normalizedFilePath.endsWith('.d.ts')) {
+  if (filePath.endsWith('.d.ts')) {
     return false
   }
 
-  return SOURCE_EXTENSIONS.has(path.extname(normalizedFilePath).toLowerCase())
-}
-
-function normalizePath(filePath: string): string {
-  return path.normalize(filePath)
+  return SOURCE_EXTENSIONS.has(path.extname(filePath).toLowerCase())
 }