feat: add support for pnpm-workspace.yaml (#6)

* feat: use `yaml`

* feat: yaml pattern

* implement `getDependenciesInfo`

* type safe

* provide more specific info

* implement `getDependencyInfoByOffset`

* refactor: better name

Author: 9romise

package.json

@@ -87,6 +87,7 @@
     "reactive-vscode": "^0.4.1",
     "tsdown": "^0.20.1",
     "typescript": "^5.9.3",
-    "vscode-ext-gen": "1.3.0"
+    "vscode-ext-gen": "1.3.0",
+    "yaml": "^2.8.2"
   }
 }

pnpm-lock.yaml

@@ -1,3 +1,6 @@
 export const PACKAGE_JSON_PATTERN = '**/package.json'
+export const PNPM_WORKSPACE_PATTERN = '**/pnpm-workspace.yaml'
+
+export const VERSION_TRIGGER_CHARACTERS = ['.', '^', '~', ...Array.from({ length: 10 }).map((_, i) => `${i}`)]
 
 export const NPM_REGISTRY = 'https://registry.npmjs.org'

src/constants.ts

@@ -1,11 +1,12 @@
 import type { DependencyInfo, Extractor } from '#types/extractor'
 import type { Node } from 'jsonc-parser'
 import type { TextDocument } from 'vscode'
+import { isInRange } from '#utils/ast'
 import { createCachedParse } from '#utils/data'
 import { findNodeAtLocation, findNodeAtOffset, parseTree } from 'jsonc-parser'
 import { Range } from 'vscode'
 
-const DEP_SECTIONS = [
+const DEPENDENCY_SECTIONS = [
   'dependencies',
   'devDependencies',
   'peerDependencies',
@@ -17,58 +18,68 @@ export class JsonExtractor implements Extractor<Node> {
 
   getNodeRange(doc: TextDocument, node: Node) {
     const start = doc.positionAt(node.offset + 1)
-    const end = doc.positionAt(
-      node.offset + node.length - 1,
-    )
+    const end = doc.positionAt(node.offset + node.length - 1)
 
     return new Range(start, end)
   }
 
-  inDependencySection(root: Node, node: Node) {
-    return DEP_SECTIONS.some((section) => {
+  isInDependencySection(root: Node, node: Node) {
+    return DEPENDENCY_SECTIONS.some((section) => {
       const dep = findNodeAtLocation(root, [section])
       if (!dep || !dep.parent)
         return false
 
       const { offset, length } = dep.parent.children![1]
 
-      return node.offset > offset && node.offset < offset + length
+      return isInRange(node.offset, [offset, offset + length])
     })
   }
 
+  private parseDependencyNode(node: Node): DependencyInfo<Node> | undefined {
+    if (!node.children?.length)
+      return
+
+    const [nameNode, versionNode] = node.children
+
+    if (
+      typeof nameNode?.value !== 'string'
+      || typeof versionNode.value !== 'string'
+    ) {
+      return
+    }
+
+    return {
+      nameNode,
+      versionNode,
+      name: nameNode.value,
+      version: versionNode.value,
+    }
+  }
+
   getDependenciesInfo(root: Node) {
-    const info: DependencyInfo<Node>[] = []
+    const result: DependencyInfo<Node>[] = []
 
-    DEP_SECTIONS.forEach((section) => {
+    DEPENDENCY_SECTIONS.forEach((section) => {
       const node = findNodeAtLocation(root, [section])
       if (!node || !node.children)
         return
 
       for (const dep of node.children) {
-        const keyNode = dep.children?.[0]
-        if (!keyNode || typeof keyNode.value !== 'string')
-          continue
-
-        info.push({
-          node: keyNode,
-          name: keyNode.value,
-          version: '',
-        })
+        const info = this.parseDependencyNode(dep)
+
+        if (info)
+          result.push(info)
       }
     })
 
-    return info
+    return result
   }
 
   getDependencyInfoByOffset(root: Node, offset: number) {
     const node = findNodeAtOffset(root, offset)
-    if (!node || node.type !== 'string' || !this.inDependencySection(root, node))
+    if (!node || node.type !== 'string' || !this.isInDependencySection(root, node))
       return
 
-    return {
-      node,
-      name: node.parent!.children![0].value as string,
-      version: node.value as string,
-    }
+    return this.parseDependencyNode(node.parent!)
   }
 }

src/extractors/json.ts

@@ -0,0 +1,98 @@
+import type { DependencyInfo, Extractor } from '#types/extractor'
+import type { TextDocument } from 'vscode'
+import type { Node, Pair, Scalar, YAMLMap } from 'yaml'
+import { isInRange } from '#utils/ast'
+import { createCachedParse } from '#utils/data'
+import { Range } from 'vscode'
+import { isMap, isPair, isScalar, parseDocument } from 'yaml'
+
+const CATALOG_SECTION = 'catalog'
+const CATALOGS_SECTION = 'catalogs'
+
+type CatalogEntry = Pair<Scalar<string>, Scalar<string>>
+
+type CatalogEntryVisitor = (catalog: CatalogEntry) => boolean | void
+
+export class YamlExtractor implements Extractor<Node> {
+  parse = createCachedParse((text) => parseDocument(text).contents)
+
+  getNodeRange(doc: TextDocument, node: Node) {
+    const [start, end] = node.range!
+
+    return new Range(
+      doc.positionAt(start),
+      doc.positionAt(end),
+    )
+  }
+
+  getDependenciesInfo(root: Node): DependencyInfo<Node>[] {
+    if (!isMap(root))
+      return []
+
+    const result: DependencyInfo<Node>[] = []
+
+    this.traverseCatalogs(root, (item) => {
+      result.push({
+        nameNode: item.key,
+        versionNode: item.value!,
+        name: String(item.key.value),
+        version: String(item.value!.value),
+      })
+    })
+
+    return result
+  }
+
+  private traverseCatalogs(root: YAMLMap, callback: CatalogEntryVisitor): boolean {
+    const catalog = root.items.find((i) => isScalar(i.key) && i.key.value === CATALOG_SECTION)
+    if (this.traverseCatalog(catalog, callback))
+      return true
+
+    const catalogs = root.items.find((i) => isScalar(i.key) && i.key.value === CATALOGS_SECTION)
+    if (isMap(catalogs?.value)) {
+      for (const c of catalogs.value.items) {
+        if (this.traverseCatalog(c, callback))
+          return true
+      }
+    }
+
+    return false
+  }
+
+  private traverseCatalog(catalog: unknown, callback: CatalogEntryVisitor): boolean {
+    if (!isPair(catalog))
+      return false
+    if (!isMap(catalog.value))
+      return false
+
+    for (const item of catalog.value.items) {
+      if (isScalar(item.key) && isScalar(item.value)) {
+        if (callback(item as CatalogEntry))
+          return true
+      }
+    }
+
+    return false
+  }
+
+  getDependencyInfoByOffset(root: Node, offset: number): DependencyInfo<Node> | undefined {
+    if (!isMap(root))
+      return
+
+    let result: DependencyInfo<Node> | undefined
+
+    this.traverseCatalogs(root, (item) => {
+      if (isInRange(offset, item.value!.range!)) {
+        result = {
+          nameNode: item.key,
+          versionNode: item.value!,
+          name: String(item.key.value),
+          version: String(item.value!.value),
+        }
+        return true
+      }
+    })
+
+    return result
+  }
+}

src/extractors/yaml.ts

@@ -1,30 +1,41 @@
-import { PACKAGE_JSON_PATTERN } from '#constants'
+import { PACKAGE_JSON_PATTERN, PNPM_WORKSPACE_PATTERN, VERSION_TRIGGER_CHARACTERS } from '#constants'
 import { defineExtension } from 'reactive-vscode'
 import { languages } from 'vscode'
 import { JsonExtractor } from './extractors/json'
+import { YamlExtractor } from './extractors/yaml'
 import { displayName, version } from './generated-meta'
-import { triggerChars, VersionCompletionItemProvider } from './providers/completion-item/version'
+import { VersionCompletionItemProvider } from './providers/completion-item/version'
 import { NpmxDocumentLinkProvider } from './providers/document-link/npmx'
 import { config, logger } from './state'
 
 export const { activate, deactivate } = defineExtension((ctx) => {
   logger.info(`${displayName} Activated, v${version}`)
 
   const jsonExtractor = new JsonExtractor()
+  const yamlExtractor = new YamlExtractor()
 
   ctx.subscriptions.push(
     languages.registerDocumentLinkProvider(
       { pattern: PACKAGE_JSON_PATTERN },
       new NpmxDocumentLinkProvider(jsonExtractor),
     ),
+    languages.registerDocumentLinkProvider(
+      { pattern: PNPM_WORKSPACE_PATTERN },
+      new NpmxDocumentLinkProvider(yamlExtractor),
+    ),
   )
 
   if (config.versionCompletion !== 'off') {
     ctx.subscriptions.push(
       languages.registerCompletionItemProvider(
         { pattern: PACKAGE_JSON_PATTERN },
         new VersionCompletionItemProvider(jsonExtractor),
-        ...triggerChars,
+        ...VERSION_TRIGGER_CHARACTERS,
+      ),
+      languages.registerCompletionItemProvider(
+        { pattern: PNPM_WORKSPACE_PATTERN },
+        new VersionCompletionItemProvider(yamlExtractor),
+        ...VERSION_TRIGGER_CHARACTERS,
       ),
     )
   }

src/index.ts

@@ -8,15 +8,13 @@ function isVersionPrefix(c: string) {
   return c === '^' || c === '~'
 }
 
-function getPrefix(v: string) {
+function extractVersionPrefix(v: string) {
   const firstChar = v[0]
   const valid = isVersionPrefix(firstChar)
 
   return valid ? firstChar : ''
 }
 
-export const triggerChars = ['.', '^', '~', ...Array.from({ length: 10 }).map((_, i) => `${i}`)]
-
 export class VersionCompletionItemProvider<T extends Extractor<any>> implements CompletionItemProvider {
   extractor: T
 
@@ -35,14 +33,14 @@ export class VersionCompletionItemProvider<T extends Extractor<any>> implements
       return
 
     const {
-      node,
+      versionNode,
       name,
       version,
     } = info
 
     const pkg = await getPackageInfo(name)
 
-    const prefix = getPrefix(version)
+    const prefix = extractVersionPrefix(version)
 
     let versionsKV = Object.values(pkg.versions)
 
@@ -53,7 +51,7 @@ export class VersionCompletionItemProvider<T extends Extractor<any>> implements
       const text = `${prefix}${version}`
       const item = new CompletionItem(text, CompletionItemKind.Value)
 
-      item.range = this.extractor.getNodeRange(document, node)
+      item.range = this.extractor.getNodeRange(document, versionNode)
       item.insertText = text
       if (tag)
         item.detail = tag

src/providers/completion-item/version.ts

@@ -14,8 +14,8 @@ export class NpmxDocumentLinkProvider<T extends Extractor<any>> implements Docum
     if (!root)
       return
 
-    return this.extractor.getDependenciesInfo(root).map(({ node, name }) => {
-      const range = this.extractor.getNodeRange(document, node)
+    return this.extractor.getDependenciesInfo(root).map(({ nameNode, name }) => {
+      const range = this.extractor.getNodeRange(document, nameNode)
 
       const uri = Uri.parse(`https://npmx.dev/package/${name}`)
 

src/providers/document-link/npmx.ts

@@ -1,13 +1,14 @@
 import type { Range, TextDocument } from 'vscode'
 
 export interface DependencyInfo<T> {
-  node: T
+  nameNode: T
+  versionNode: T
   name: string
   version: string
 }
 
 export interface Extractor<T> {
-  parse: (document: TextDocument) => T | undefined
+  parse: (document: TextDocument) => T | null | undefined
 
   getNodeRange: (document: TextDocument, node: T) => Range
 

src/types/extractor.ts

@@ -0,0 +1,3 @@
+export function isInRange(offset: number, [start, end]: [number, number, ...any]): boolean {
+  return offset >= start && offset <= end
+}