coc-vscode-loader 1.1.2 → 1.1.5

package/converter/src/scanner.ts

@@ -0,0 +1,136 @@
+import * as fs from 'fs'
+import * as path from 'path'
+
+export interface ScanResult {
+  files: ScannedFile[]
+  hasTsBridge: boolean
+  hasDecoration: boolean
+  hasWebview: boolean
+  summary: string
+}
+
+export interface ScannedFile {
+  path: string
+  apis: string[]
+  actions: string[]
+}
+
+const UNSUPPORTED_PATTERNS = [
+  { pattern: 'createTextEditorDecorationType', action: 'mark-unsupported', label: 'decoration API' },
+  { pattern: 'setDecorations', action: 'mark-unsupported', label: 'decoration API' },
+  { pattern: 'createWebviewPanel', action: 'mark-unsupported', label: 'webview API' },
+  { pattern: 'registerTreeDataProvider', action: 'mark-unsupported', label: 'tree data provider' },
+  { pattern: 'window.showInputBox', action: 'needs-rewrite', label: 'use requestInput instead' },
+  { pattern: 'env.openExternal', action: 'mark-unsupported', label: 'no equivalent' },
+  { pattern: 'showOpenDialog', action: 'mark-unsupported', label: 'no equivalent' },
+  { pattern: 'showSaveDialog', action: 'mark-unsupported', label: 'no equivalent' },
+]
+
+const TS_BRIDGE_PATTERNS = [
+  'tsserver/request',
+  'tsserver/response',
+  '_vue:',
+  'typescript.tsserverRequest',
+]
+
+export function scan(dir: string): ScanResult {
+  const files: ScannedFile[] = []
+  let hasTsBridge = false
+  let hasDecoration = false
+  let hasWebview = false
+
+  const tsFiles = walk(dir).filter(f => f.endsWith('.ts') || f.endsWith('.tsx'))
+
+  for (const filePath of tsFiles) {
+    const content = fs.readFileSync(filePath, 'utf-8')
+    const apis: string[] = []
+    const actions: string[] = []
+    const relative = path.relative(dir, filePath)
+
+    // Check for vscode imports
+    if (content.includes("from 'vscode'") || content.includes('from "vscode"') || content.includes('require("vscode")')) {
+      apis.push('vscode')
+    }
+
+    // Check for unsupported patterns
+    for (const { pattern, action, label } of UNSUPPORTED_PATTERNS) {
+      if (content.includes(pattern)) {
+        apis.push(label)
+        actions.push(action)
+        if (action === 'mark-unsupported') {
+          if (label.includes('decoration')) hasDecoration = true
+          if (label.includes('webview')) hasWebview = true
+        }
+      }
+    }
+
+    // Check for TS bridge
+    for (const pattern of TS_BRIDGE_PATTERNS) {
+      if (content.includes(pattern)) {
+        hasTsBridge = true
+        apis.push('tsserver bridge')
+        break
+      }
+    }
+
+    // Check for LanguageClient
+    if (content.includes('LanguageClient')) {
+      apis.push('LanguageClient')
+    }
+
+    // Check for typescriptServerPlugins in package.json
+    if (relative === 'package.json' || filePath.endsWith('package.json')) {
+      if (content.includes('typescriptServerPlugins')) {
+        hasTsBridge = true
+        apis.push('typescriptServerPlugins')
+      }
+    }
+
+    if (apis.length > 0) {
+      files.push({ path: relative, apis, actions })
+    }
+  }
+
+  // Read package.json
+  const pkgPath = path.join(dir, 'package.json')
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
+    const apis: string[] = []
+    if (pkg.contributes?.typescriptServerPlugins) {
+      hasTsBridge = true
+      apis.push('typescriptServerPlugins')
+    }
+    if (pkg.activationEvents) {
+      apis.push(`activationEvents: ${pkg.activationEvents.length}`)
+    }
+    if (apis.length > 0) {
+      files.push({ path: 'package.json', apis, actions: [] })
+    }
+  }
+
+  return {
+    files,
+    hasTsBridge,
+    hasDecoration,
+    hasWebview,
+    summary: [
+      `found ${files.length} files with vscode API`,
+      hasTsBridge ? ', ts-bridge detected' : '',
+      hasDecoration ? ', decoration API (marked)' : '',
+      hasWebview ? ', webview API (marked)' : '',
+    ].join(''),
+  }
+}
+
+function walk(dir: string): string[] {
+  const files: string[] = []
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, entry.name)
+    if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+      files.push(...walk(p))
+    } else if (entry.isFile()) {
+      files.push(p)
+    }
+  }
+  return files
+}

package/converter/src/transforms/class-to-factory.ts

@@ -0,0 +1,54 @@
+import { Transform } from '../types.js'
+import { SyntaxKind } from 'ts-morph'
+
+const FACTORY_TYPES = new Set([
+  'Position', 'Range', 'Location', 'LocationLink',
+  'Diagnostic', 'DiagnosticRelatedInformation',
+  'TextEdit',
+  'Hover', 'CompletionItem', 'CompletionList',
+  'CodeAction', 'CodeLens', 'DocumentLink',
+  'Color', 'ColorInformation', 'ColorPresentation',
+  'FoldingRange', 'SelectionRange',
+  'DocumentHighlight', 'SymbolInformation', 'DocumentSymbol',
+  'ParameterInformation', 'SignatureInformation',
+  'CallHierarchyItem', 'CallHierarchyIncomingCall', 'CallHierarchyOutgoingCall',
+  'TypeHierarchyItem', 'LinkedEditingRanges',
+])
+
+export const transformClassToFactory: Transform = (ctx) => {
+  const { file } = ctx
+
+  // AST approach: try to replace via ts-morph
+  const nodes = file.getDescendantsOfKind(SyntaxKind.NewExpression)
+  const astReplacements: Array<{ node: any, text: string }> = []
+  for (const expr of nodes) {
+    const text = expr.getText()
+    const m = text.match(/^new\s+(\w+)\(/)
+    if (!m || !FACTORY_TYPES.has(m[1])) continue
+    const args = text.slice(m[0].length, -1)
+    astReplacements.push({ node: expr, text: `${m[1]}.create(${args})` })
+  }
+  for (const { node, text } of astReplacements) {
+    try { node.replaceWithText(text) } catch {}
+  }
+
+  // Text fallback: catch remaining new Xxx() that AST might have missed
+  let text = file.getText()
+  text = text.replace(
+    /\bnew\s+(Position|Range|Location|Diagnostic|TextEdit)\s*\(/g,
+    (match, type) => `${type}.create(`
+  )
+
+  // CompletionItem.create(label) doesn't accept kind in coc.
+  // Convert `CompletionItem.create(label, kind)` to `item = CompletionItem.create(label); item.kind = kind`
+  text = text.replace(
+    /const\s+(\w+)\s*=\s*CompletionItem\.create\(([^,]+),\s*([^)]+)\)/g,
+    (_, varName, label, kind) => {
+      return `const ${varName} = CompletionItem.create(${label}); ${varName}.kind = ${kind}`
+    }
+  )
+
+  if (text !== file.getText()) {
+    file.replaceWithText(text)
+  }
+}

package/converter/src/transforms/enum-offset.ts

@@ -0,0 +1,49 @@
+import { Transform } from '../types.js'
+
+/**
+ * Handle enum value offsets between VS Code (0-based) and coc (1-based LSP).
+ * Some enums like DiagnosticSeverity, CompletionItemKind, SymbolKind have
+ * different numeric values, but since coc re-exports them with correct values,
+ * symbol references (like CompletionItemKind.Value) work correctly at runtime.
+ *
+ * This transform handles cases where hardcoded numbers are used instead of
+ * enum symbols, which is rare but can happen in extensions.
+ *
+ * Affected enums and their offset:
+ *   CompletionItemKind:      vscode Text=0 → coc Text:1  (differs by 1 for first ~11 values)
+ *   SymbolKind:              vscode File=0 → coc File:1
+ *   DocumentHighlightKind:   vscode Text=0 → coc Text:1
+ *   DiagnosticSeverity:      vscode Error=0 → coc Error:1
+ */
+export const transformEnumOffset: Transform = (ctx) => {
+  const { file } = ctx
+  let content = file.getText()
+
+  // Detect hardcoded numbers used in enum position (e.g., CompletionItemKind.Xxx).
+  // This is hard to detect perfectly, so we log a note when numeric literals
+  // appear near enum-type names.
+  const enumPatterns = [
+    'CompletionItemKind', 'SymbolKind', 'DocumentHighlightKind', 'DiagnosticSeverity',
+    'CompletionTriggerKind', 'InlineCompletionTriggerKind',
+  ]
+
+  for (const enumName of enumPatterns) {
+    // Check if the enum is imported/used with a hardcoded number nearby
+    const enumRefs = content.match(new RegExp(`${enumName}\\.\\w+`, 'g'))
+    if (enumRefs) {
+      // Symbol references are fine - they resolve at runtime
+      // Only note if there are raw numbers being compared
+    }
+  }
+
+  // Replace any numeric enum comparisons with comments
+  // e.g., `severity === 0` → `severity === 0 /* DiagnosticSeverity.Error = 1 in coc */`
+  content = content.replace(
+    /(severity\s*[=!]==?\s*)(\d+)/g,
+    '$1$2 /* DiagnosticSeverity values differ in coc (1-4 vs 0-3) */'
+  )
+
+  if (content !== file.getText()) {
+    file.replaceWithText(content)
+  }
+}

package/converter/src/transforms/import-mapping.ts

@@ -0,0 +1,47 @@
+import { Transform } from '../types.js'
+
+/**
+ * Replace `from 'vscode'` with `from 'coc.nvim'`,
+ * and apply name remapping for known API differences.
+ */
+const MAPPINGS: Record<string, string> = {
+  // namespace
+  'vscode': 'coc.nvim',
+
+  // naming differences
+  'EventEmitter': 'Emitter',
+  'Disposable': 'Disposable',
+
+  // function/method renames
+  'getExtension': 'getExtensionById',
+  'registerReferenceProvider': 'registerReferencesProvider',
+  'registerCodeActionsProvider': 'registerCodeActionProvider',
+  'registerColorProvider': 'registerDocumentColorProvider',
+  'registerDocumentFormattingEditProvider': 'registerDocumentFormatProvider',
+  'registerDocumentRangeFormattingEditProvider': 'registerDocumentRangeFormatProvider',
+}
+
+export const transformImportMapping: Transform = (ctx) => {
+  const { file } = ctx
+
+  // Rewrite import declarations
+  file.getImportDeclarations().forEach(decl => {
+    const mod = decl.getModuleSpecifierValue()
+    if (mod === 'vscode') {
+      decl.setModuleSpecifier('coc.nvim')
+    }
+  })
+
+  // Rewrite named references
+  file.getDescendantsOfKind(192 /* Identifier */).forEach(node => {
+    const text = node.getText()
+    const mapped = MAPPINGS[text]
+    if (mapped && mapped !== text) {
+      // Only replace if it's a direct reference, not part of a string
+      const parent = node.getParent()
+      if (parent && parent.getKindName() !== 'StringLiteral') {
+        node.replaceWithText(mapped)
+      }
+    }
+  })
+}

package/converter/src/transforms/language-client.ts

@@ -0,0 +1,48 @@
+import { Transform } from '../types.js'
+
+/**
+ * Adapt LanguageClient construction from VS Code style to coc style.
+ *
+ * VS Code:
+ *   new LanguageClient('id', 'name', serverOptions, clientOptions)
+ *   serverOptions = { run: { module, transport }, debug: { module, transport } }
+ *
+ * coc:
+ *   new LanguageClient('id', 'name', serverOptions, clientOptions)
+ *   serverOptions = { module, transport, options? }
+ */
+export const transformLanguageClient: Transform = (ctx) => {
+  const { file } = ctx
+
+  file.getDescendantsOfKind(199 /* CallExpression */).forEach(call => {
+    const text = call.getText()
+
+    // Match: new LanguageClient(...)
+    if (!text.startsWith('new LanguageClient(')) return
+
+    // Extract serverOptions argument (3rd positional arg)
+    const args = call.getArguments()
+    if (args.length < 3) return
+
+    const serverOpts = args[2].getText()
+
+    // Check if it has the VS Code style { run, debug } structure
+    if (!serverOpts.includes('run:') || !serverOpts.includes('debug:')) return
+
+    // Extract module and transport from run block
+    const moduleMatch = serverOpts.match(/module:\s*(\S+)/)
+    const transportMatch = serverOpts.match(/transport:\s*(\S+)/)
+
+    if (!moduleMatch) return
+
+    // Build coc-style serverOptions
+    let cocOpts = `{\n      module: ${moduleMatch[1]}`
+    if (transportMatch) {
+      cocOpts += `,\n      transport: ${transportMatch[1]}`
+    }
+    cocOpts += '\n    }'
+
+    // Replace the argument
+    args[2].replaceWithText(cocOpts)
+  })
+}

package/converter/src/transforms/provider-register.ts

@@ -0,0 +1,55 @@
+import { Transform } from '../types.js'
+
+/**
+ * Adapt provider registration function signatures.
+ *
+ * registerCompletionItemProvider(sel, p, t) → registerCompletionItemProvider('name', 'sc', sel, p, [t])
+ * registerCodeActionsProvider(sel, p, m?)   → registerCodeActionProvider(sel, p, clientId?, kinds?)
+ * registerReferenceProvider(sel, p)         → registerReferencesProvider(sel, p)
+ * registerDocumentFormattingEditProvider    → registerDocumentFormatProvider(sel, p, priority?)
+ * registerColorProvider                     → registerDocumentColorProvider(sel, p)
+ */
+const RENAMES: Record<string, string> = {
+  registerCodeActionsProvider: 'registerCodeActionProvider',
+  registerReferenceProvider: 'registerReferencesProvider',
+  registerDocumentFormattingEditProvider: 'registerDocumentFormatProvider',
+  registerDocumentRangeFormattingEditProvider: 'registerDocumentRangeFormatProvider',
+  registerColorProvider: 'registerDocumentColorProvider',
+}
+
+export const transformProviderRegister: Transform = (ctx) => {
+  let { file } = ctx
+  let content = file.getText()
+  let changed = false
+
+  // 1. Simple renames
+  for (const [from, to] of Object.entries(RENAMES)) {
+    const re = new RegExp(`\\b${from}\\b`, 'g')
+    if (re.test(content)) {
+      content = content.replace(re, to)
+      changed = true
+    }
+  }
+
+  // 2. registerCompletionItemProvider: insert name + shortcut at beginning
+  if (content.includes('registerCompletionItemProvider')) {
+    content = content.replace(
+      /registerCompletionItemProvider\(/g,
+      `registerCompletionItemProvider('plugin', 'PL', `
+    )
+    // Wrap the last argument in an array if it's a string (trigger chars)
+    content = content.replace(
+      /(registerCompletionItemProvider\([^)]+),\s*'([^']+)'\)/g,
+      '$1, ["$2"])'
+    )
+    content = content.replace(
+      /(registerCompletionItemProvider\([^)]+),\s*"([^"]+)"\)/g,
+      '$1, ["$2"])'
+    )
+    changed = true
+  }
+
+  if (changed) {
+    file.replaceWithText(content)
+  }
+}

package/converter/src/types.ts

@@ -0,0 +1,8 @@
+import { Project, SourceFile } from 'ts-morph'
+
+export interface TransformContext {
+  file: SourceFile
+  project: Project
+}
+
+export type Transform = (ctx: TransformContext) => void

package/lib/index.js

@@ -39,7 +39,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "coc-vscode-loader",
-      version: "1.1.2",
+      version: "1.1.5",
       description: "Run VS Code extensions seamlessly in coc.nvim",
       main: "lib/index.js",
       keywords: [
@@ -58,6 +58,12 @@ var require_package = __commonJS({
         url: "https://github.com/coc-plugin/coc-vscode-loader/issues"
       },
       homepage: "https://www.npmjs.com/package/coc-vscode-loader",
+      files: [
+        "lib/",
+        "converter/src/",
+        "converter/package.json",
+        "assets/"
+      ],
       license: "MIT",
       engines: {
         coc: ">= 0.0.80"
@@ -157,8 +163,8 @@ async function updateRegistry() {
   return data.length;
 }
 function satisfiesVersion(required) {
-  const a = pluginVersion().split(".").map(Number);
-  const b = required.split(".").map(Number);
+  const a = pluginVersion().replace(/-.*$/, "").split(".").map(Number);
+  const b = required.replace(/-.*$/, "").split(".").map(Number);
   for (let i = 0; i < Math.max(a.length, b.length); i++) {
     const va = a[i] || 0, vb = b[i] || 0;
     if (va > vb) return true;
@@ -433,10 +439,15 @@ async function run(cmd, args, cwd, onLine) {
     };
     child.stdout.on("data", handler);
     child.stderr.on("data", handler);
+    let stderrBuf = "";
+    child.stderr.on("data", (d) => {
+      stderrBuf += d.toString();
+    });
     child.on("close", (code) => {
       clearTimeout(timer);
       if (code === 0) resolve2();
-      else reject(new Error(`${cmd} ${args.join(" ")} exited with code ${code}`));
+      else reject(new Error(`${cmd} ${args.join(" ")} exited with code ${code}
+${stderrBuf.trim()}`));
     });
     child.on("error", (e) => {
       clearTimeout(timer);
@@ -500,7 +511,17 @@ async function buildPackage(name, inputDir, info, onProgress) {
     }
     if (!pythonBin) throw new Error("python3 not found, cannot install pip packages: " + info.pipPackages.join(", "));
     const pipArgs = ["-m", "pip", "install"];
-    if (process.platform === "linux") pipArgs.push("--break-system-packages");
+    if (process.platform === "linux" || process.platform === "darwin") {
+      try {
+        const verOut = await runWithOutput(pythonBin, ["--version"], build);
+        const m = verOut.match(/^Python\s+(\d+)\.(\d+)/);
+        if (m) {
+          const pyMajor = parseInt(m[1]), pyMinor = parseInt(m[2]);
+          if (pyMajor > 3 || pyMajor === 3 && pyMinor >= 11) pipArgs.push("--break-system-packages");
+        }
+      } catch {
+      }
+    }
     onProgress(3, 5, "Installing pip packages...", `${pythonBin} -m pip install ${info.pipPackages.join(" ")}`);
     await run(pythonBin, pipArgs.concat(...info.pipPackages), build, pipLog);
   }
@@ -577,6 +598,10 @@ async function buildPackage(name, inputDir, info, onProgress) {
           /try\s*\{[^}]*?require\.resolve\([^)]+\)\s*;?\s*\}\s*catch\s*\{\s*\}/g,
           `try { serverModule = ${serverPath} } catch {}`
         );
+        code = code.replace(
+          /let\s+serverModule\s*=\s*config\.get\([^)]+\)\s*;?\s*/g,
+          `let serverModule = ${serverPath};`
+        );
         fs3.writeFileSync(indexPath, code);
       }
     } catch (e) {
@@ -591,7 +616,6 @@ async function buildPackage(name, inputDir, info, onProgress) {
       /documentSelector:\s*\[\s*\{[^}]*?language:\s*['"][^'"]*['"][^}]*\}\s*\]/,
       `documentSelector: [${langSelector}]`
     );
-    code = code.replace(/serverModule\s*=\s*require\("path"\)\.join\(_dir,\s*_entry\);\s*/g, "");
     code = code.replace(
       /client\.start\(\);/g,
       "client.start().catch(() => {/* init may complete async */});"
@@ -625,6 +649,7 @@ async function installToCoc(name, onProgress) {
   fs3.cpSync(src, dest, { recursive: true });
   const pkgPath = extensionsPkgPath();
   const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+  pkg.dependencies = pkg.dependencies || {};
   const depName = `coc-${name}`;
   if (!pkg.dependencies[depName]) {
     pkg.dependencies[depName] = `file:${dest}`;
@@ -697,6 +722,7 @@ async function uninstallPackage(state, name) {
     state.setPackageStatus(name, "uninstalling", { progress: "[2/3] Removing from package.json..." });
     const pkgPath = extensionsPkgPath();
     const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+    pkg.dependencies = pkg.dependencies || {};
     const depName = `coc-${name}`;
     if (pkg.dependencies[depName]) {
       delete pkg.dependencies[depName];
@@ -958,6 +984,7 @@ var TUI = class {
       G: "G"
     };
     this.rendering = false;
+    this.pendingRender = false;
     this.state = state;
   }
   async open() {
@@ -1003,7 +1030,8 @@ var TUI = class {
     await nvim.call("nvim_win_set_option", [this.winid, "spell", false]);
     await nvim.call("nvim_win_set_option", [this.winid, "foldenable", false]);
     this.unsubscribe = this.state.subscribe(() => {
-      this.render();
+      this.render().catch(() => {
+      });
     });
     this.disposables.push(
       import_coc2.workspace.registerAutocmd({
@@ -1030,11 +1058,14 @@ var TUI = class {
       `);
     }
     await this.setupKeymaps();
-    updateRegistry().then(() => this.state.refreshPackages()).catch(() => {
+    await this.render();
+    updateRegistry().then(() => {
+      this.state.refreshPackages();
+      this.render();
+    }).catch(() => {
       this.state.setStatusMessage("Failed to fetch remote registry (offline?)");
       setTimeout(() => this.state.setStatusMessage(), 5e3);
     });
-    await this.render();
   }
   async getCursorLine0() {
     const nvim = import_coc2.workspace.nvim;
@@ -1123,7 +1154,7 @@ var TUI = class {
       }
       const ok = await import_coc2.window.showPrompt(`Uninstall ${removed.length} orphaned package(s)?`);
       if (ok) {
-        for (const p of removed) uninstallPackage(this.state, p.info.name);
+        for (const p of removed) await uninstallPackage(this.state, p.info.name);
       }
       return;
     }
@@ -1141,7 +1172,7 @@ var TUI = class {
       if (installed.length === 0) return;
       const ok = await import_coc2.window.showPrompt(`Uninstall all ${installed.length} packages?`);
       if (ok) {
-        for (const pkg of installed) uninstallPackage(this.state, pkg.info.name);
+        for (const pkg of installed) await uninstallPackage(this.state, pkg.info.name);
       }
       return;
     }
@@ -1235,8 +1266,13 @@ var TUI = class {
     }
   }
   async render() {
-    if (!this.winid || this.rendering) return;
+    if (!this.winid) return;
+    if (this.rendering) {
+      this.pendingRender = true;
+      return;
+    }
     this.rendering = true;
+    this.pendingRender = false;
     try {
       const nvim = import_coc2.workspace.nvim;
       const state = this.state.getState();
@@ -1259,6 +1295,7 @@ var TUI = class {
       this.logLineSet = result.logLines;
     } finally {
       this.rendering = false;
+      if (this.pendingRender) this.render();
     }
   }
   renderHelp() {
@@ -1505,7 +1542,7 @@ async function activate(context) {
       const ok = await import_coc3.window.showPrompt(`Uninstall all ${installed.length} packages?`);
       if (ok) {
         for (const pkg of installed) {
-          uninstallPackage(state, pkg.info.name);
+          await uninstallPackage(state, pkg.info.name);
         }
       }
     })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coc-vscode-loader",
-  "version": "1.1.2",
+  "version": "1.1.5",
   "description": "Run VS Code extensions seamlessly in coc.nvim",
   "main": "lib/index.js",
   "keywords": [
@@ -19,6 +19,12 @@
     "url": "https://github.com/coc-plugin/coc-vscode-loader/issues"
   },
   "homepage": "https://www.npmjs.com/package/coc-vscode-loader",
+  "files": [
+    "lib/",
+    "converter/src/",
+    "converter/package.json",
+    "assets/"
+  ],
   "license": "MIT",
   "engines": {
     "coc": ">= 0.0.80"