refactor: class WorkspaceContext

Author: 9romise

src/composables/workspace-context.ts

@@ -2,20 +2,20 @@ import type { Uri } from 'vscode'
 import { SUPPORTED_DOCUMENT_PATTERN } from '#constants'
 import { isSupportedDependencyDocument } from '#extractors'
 import { logger } from '#state'
-import { getWorkspaceContextState } from '#utils/workspace'
+import { getWorkspaceContext } from '#utils/workspace'
 import { useActiveTextEditor, useDocumentText, useFileSystemWatcher, watch } from 'reactive-vscode'
 import { workspace } from 'vscode'
 
 export function useWorkspaceContext() {
   workspace.onDidChangeWorkspaceFolders(({ removed }) => {
     removed.forEach((folder) => {
-      getWorkspaceContextState.delete(folder.uri)
+      getWorkspaceContext.delete(folder.uri)
       logger.info(`[workspace-context] delete workspace folder cache: ${folder.uri.path}`)
     })
   })
 
   async function deleteCacheByUri(uri: Uri) {
-    const ctx = await getWorkspaceContextState(uri)
+    const ctx = await getWorkspaceContext(uri)
     if (!ctx)
       return
 

src/index.ts

@@ -15,10 +15,10 @@ export const { activate, deactivate } = defineExtension(() => {
 
   useWorkspaceContext()
 
-  useDiagnostics()
-  useCodeActions()
   useHover()
   useCompletionItem()
+  useDiagnostics()
+  useCodeActions()
   useDocumentLink()
 
   useCommands({

src/providers/diagnostics/rules/engine-mismatch.ts

@@ -2,7 +2,7 @@ import type { Engines } from 'fast-npm-meta'
 import type { DiagnosticRule } from '..'
 import { npmxPackageUrl } from '#utils/links'
 import { formatPackageId } from '#utils/package'
-import { getWorkspaceContextState, isPackageManifestPath } from '#utils/workspace'
+import { getWorkspaceContext, isPackageManifestPath } from '#utils/workspace'
 import Range from 'semver/classes/range'
 import intersects from 'semver/ranges/intersects'
 import subset from 'semver/ranges/subset'
@@ -55,7 +55,7 @@ export const checkEngineMismatch: DiagnosticRule = async ({ uri, dep, pkg }) =>
   if (!exactVersion)
     return
 
-  const state = await getWorkspaceContextState(uri)
+  const state = await getWorkspaceContext(uri)
   const engines = (await state?.loadPackageManifestInfo(uri))?.engines
 
   if (!engines)

src/types/context.ts

@@ -15,11 +15,6 @@ export type DependencyProtocol
 
 export type CatalogsInfo = Record<string, Record<string, string>>
 
-export interface WorkspaceContext {
-  packageManager: PackageManager
-  catalogs?: CatalogsInfo
-}
-
 export interface ResolvedDependencyInfo extends DependencyInfo {
   protocol: DependencyProtocol
   resolvedName: string

src/utils/shared.ts

@@ -0,0 +1,8 @@
+export function lazyInit<T>(factory: () => T): () => T {
+  let cached: { value: T } | undefined
+  return () => {
+    if (!cached)
+      cached = { value: factory() }
+    return cached.value
+  }
+}

src/utils/workspace.ts

@@ -1,6 +1,6 @@
-import type { CatalogsInfo, ResolvedDependencyInfo, WorkspaceContext } from '#types/context'
+import type { CatalogsInfo, PackageManager, ResolvedDependencyInfo } from '#types/context'
 import type { DependencyInfo, PackageManifestInfo, WorkspaceCatalogInfo } from '#types/extractor'
-import type { MemoizedFunction } from '#utils/memoize'
+import type { MemoizeOptions } from '#utils/memoize'
 import type { WorkspaceFolder } from 'vscode'
 import { packageManifestExtractorEntry, workspaceCatalogExtractorEntries } from '#extractors'
 import { logger } from '#state'
@@ -12,69 +12,99 @@ import { resolveExactVersion } from '#utils/package'
 import { detectPackageManager } from '#utils/package-manager'
 import { Uri, workspace } from 'vscode'
 import { getDocumentText } from './document'
+import { lazyInit } from './shared'
 
 type WithResolvedDependencyInfo<T> = Omit<T, 'dependencies'> & {
   dependencies: ResolvedDependencyInfo[]
 }
 
-interface WorkspaceContextState {
-  folder: WorkspaceFolder
-  workspaceContext: WorkspaceContext
-  loadPackageManifestInfo: MemoizedFunction<Uri, Promise<WithResolvedDependencyInfo<PackageManifestInfo> | undefined>>
-  loadWorkspaceCatalogInfo: MemoizedFunction<Uri, Promise<WithResolvedDependencyInfo<WorkspaceCatalogInfo> | undefined>>
-}
-
 export function isPackageManifestPath(path: string) {
   return path.endsWith(`/${packageManifestExtractorEntry.basename}`)
 }
 
-function lazyInit<T>(factory: () => T): () => T {
-  let cached: { value: T } | undefined
-  return () => {
-    if (!cached)
-      cached = { value: factory() }
-    return cached.value
+class WorkspaceContext {
+  folder: WorkspaceFolder
+  packageManager: PackageManager = 'npm'
+  catalogs?: CatalogsInfo
+
+  constructor(folder: WorkspaceFolder) {
+    this.folder = folder
+    this.#init()
   }
-}
 
-function createResolvedDependencyInfo(
-  dependency: DependencyInfo,
-  catalogs?: CatalogsInfo,
-): ResolvedDependencyInfo {
-  const resolution = resolveDependencySpec(dependency.rawName, dependency.rawSpec, catalogs)
-
-  const packageInfo = lazyInit(
-    async () => resolution.resolvedProtocol === 'npm'
-      ? await getPackageInfo(resolution.resolvedName) ?? null
-      : null,
-  )
-
-  return {
-    ...dependency,
-    ...resolution,
-    categoryName: dependency.categoryName ?? resolution.categoryName,
-    packageInfo,
-    resolvedVersion: lazyInit(async () => {
-      if (resolution.resolvedProtocol !== 'npm')
-        return null
-
-      const pkg = await packageInfo()
-      if (!pkg)
-        return null
-
-      return resolveExactVersion(pkg, resolution.resolvedSpec)
-    }),
+  async #init() {
+    this.packageManager = await detectPackageManager(this.folder)
+
+    if (this.packageManager !== 'npm') {
+      const workspaceFilename = workspaceCatalogExtractorEntries.find(
+        (entry) => this.packageManager === entry.packageManager,
+      )!.basename
+      const workspaceFile = Uri.joinPath(
+        this.folder.uri,
+        workspaceFilename,
+      )
+      this.catalogs = (await this.loadWorkspaceCatalogInfo(workspaceFile))?.catalogs
+    }
   }
-}
 
-export const getWorkspaceContextState = memoize<Uri, Promise<WorkspaceContextState | undefined>>(async (uri) => {
-  const folder = workspace.getWorkspaceFolder(uri)
-  if (!folder)
-    return
+  #memoizeOptions: MemoizeOptions<Uri> = {
+    getKey: (uri) => uri.path,
+    ttl: false,
+    maxSize: Number.POSITIVE_INFINITY,
+    fallbackToCachedOnError: false,
+  }
+
+  #createResolvedDependencyInfo(dependency: DependencyInfo): ResolvedDependencyInfo {
+    const resolution = resolveDependencySpec(dependency.rawName, dependency.rawSpec, this.catalogs)
+
+    const packageInfo = lazyInit(
+      async () => resolution.resolvedProtocol === 'npm'
+        ? await getPackageInfo(resolution.resolvedName) ?? null
+        : null,
+    )
+
+    return {
+      ...dependency,
+      ...resolution,
+      categoryName: dependency.categoryName ?? resolution.categoryName,
+      packageInfo,
+      resolvedVersion: lazyInit(async () => {
+        if (resolution.resolvedProtocol !== 'npm')
+          return null
+
+        const pkg = await packageInfo()
+        if (!pkg)
+          return null
+
+        return resolveExactVersion(pkg, resolution.resolvedSpec)
+      }),
+    }
+  }
+
+  loadPackageManifestInfo = memoize<
+    Uri,
+    Promise<WithResolvedDependencyInfo<PackageManifestInfo> | undefined>
+  >(async (uri) => {
+    if (!isPackageManifestPath(uri.path))
+      return
 
-  const packageManager = await detectPackageManager(folder)
+    logger.info(`[workspace-context] load package manifest info: ${uri.path}`)
+    const text = await getDocumentText(uri)
 
-  const loadWorkspaceCatalogInfo = memoize(async (uri: Uri): Promise<WithResolvedDependencyInfo<WorkspaceCatalogInfo> | undefined> => {
+    const info = packageManifestExtractorEntry.extractor.getPackageManifestInfo(text)
+    if (!info)
+      return
+
+    return {
+      ...info,
+      dependencies: info.dependencies.map(this.#createResolvedDependencyInfo),
+    }
+  }, this.#memoizeOptions)
+
+  loadWorkspaceCatalogInfo = memoize<
+    Uri,
+    Promise<WithResolvedDependencyInfo<WorkspaceCatalogInfo> | undefined>
+  >(async (uri) => {
     const path = uri.path
     logger.info(`[workspace-context] load workspace catalog info: ${path}`)
 
@@ -90,62 +120,34 @@ export const getWorkspaceContextState = memoize<Uri, Promise<WorkspaceContextSta
 
       return {
         ...info,
-        dependencies: info.dependencies.map((dependency) => createResolvedDependencyInfo(dependency)),
+        dependencies: info.dependencies.map(this.#createResolvedDependencyInfo),
       }
     }
-  }, { getKey: (uri) => uri.path, ttl: false, maxSize: Number.POSITIVE_INFINITY, fallbackToCachedOnError: false })
-
-  let catalogs: CatalogsInfo | undefined
+  }, this.#memoizeOptions)
+}
 
-  if (packageManager !== 'npm') {
-    const workspaceFile = Uri.joinPath(
-      folder.uri,
-      workspaceCatalogExtractorEntries.find((entry) => packageManager === entry.packageManager)!.basename,
-    )
-    catalogs = (await loadWorkspaceCatalogInfo(workspaceFile))?.catalogs
-  }
+export const getWorkspaceContext = memoize<Uri, Promise<WorkspaceContext | undefined>>(async (uri) => {
+  const folder = workspace.getWorkspaceFolder(uri)
+  if (!folder)
+    return
 
   logger.info(`[workspace-context] built ${folder.uri.path}`)
-
-  return {
-    folder,
-    workspaceContext: {
-      packageManager,
-      catalogs,
-    },
-    loadPackageManifestInfo: memoize(async (uri: Uri) => {
-      if (!isPackageManifestPath(uri.path))
-        return
-
-      logger.info(`[workspace-context] load package manifest info: ${uri.path}`)
-      const text = await getDocumentText(uri)
-
-      const info = packageManifestExtractorEntry.extractor.getPackageManifestInfo(text)
-      if (!info)
-        return
-
-      return {
-        ...info,
-        dependencies: info.dependencies.map((dependency) => createResolvedDependencyInfo(dependency, catalogs)),
-      }
-    }, { getKey: (uri) => uri.path, ttl: false, maxSize: Number.POSITIVE_INFINITY, fallbackToCachedOnError: false }),
-    loadWorkspaceCatalogInfo,
-  }
+  return new WorkspaceContext(folder)
 }, {
   getKey: (uri: Uri) => workspace.getWorkspaceFolder(uri)!.uri.path,
   ttl: false,
   fallbackToCachedOnError: false,
 })
 
 export async function getResolvedDependencies(uri: Uri): Promise<ResolvedDependencyInfo[] | undefined> {
-  const state = await getWorkspaceContextState(uri)
-  if (!state)
+  const ctx = await getWorkspaceContext(uri)
+  if (!ctx)
     return []
 
   return (
     isPackageManifestPath(uri.path)
-      ? await state.loadPackageManifestInfo(uri)
-      : await state.loadWorkspaceCatalogInfo(uri)
+      ? await ctx.loadPackageManifestInfo(uri)
+      : await ctx.loadWorkspaceCatalogInfo(uri)
   )?.dependencies
 }