coc-vscode-loader 1.2.9 → 1.4.0

package/converter/src/presets.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest'
+
+describe('presets', () => {
+  it('getPreset returns ts-bridge preset', async () => {
+    const { getPreset } = await import('./presets.js')
+    const preset = getPreset('ts-bridge')
+    expect(preset).toBeTruthy()
+    expect(preset!.name).toBe('ts-bridge')
+    expect(preset!.notification).toBe('tsserver/request')
+    expect(preset!.extraDeps).toContain('typescript')
+  })
+
+  it('getPreset returns undefined for unknown preset', async () => {
+    const { getPreset } = await import('./presets.js')
+    expect(getPreset('nonexistent')).toBeUndefined()
+  })
+
+  it('getActivePresets returns ts-bridge when hasTsBridge is true', async () => {
+    const { getActivePresets } = await import('./presets.js')
+    const presets = getActivePresets(true, {})
+    expect(presets).toHaveLength(1)
+    expect(presets[0].name).toBe('ts-bridge')
+  })
+
+  it('getActivePresets returns empty when hasTsBridge is false', async () => {
+    const { getActivePresets } = await import('./presets.js')
+    expect(getActivePresets(false, {})).toEqual([])
+  })
+
+  it('generateBridgeCode joins preset codes', async () => {
+    const { generateBridgeCode, getPreset } = await import('./presets.js')
+    const preset = getPreset('ts-bridge')!
+    const code = generateBridgeCode([preset, preset])
+    expect(code).toContain('tsserver')
+    expect(code).toContain('\n\n')
+  })
+})

package/converter/src/registry-validation.test.ts

@@ -0,0 +1,127 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import * as fs from 'fs'
+import * as path from 'path'
+
+interface RegistryEntry {
+  name: string
+  displayName: string
+  description: string
+  type: string
+  source: { type: string; repo?: string; package?: string; subdir?: string }
+  url: string
+  languages: string[]
+  categories: string[]
+  convert: any[]
+  minPluginVersion?: string
+}
+
+describe('registry.json validation', () => {
+  const registryPath = path.resolve(__dirname, '../../coc-vscode-registry/registry.json')
+  let entries: RegistryEntry[]
+
+  beforeAll(() => {
+    const content = fs.readFileSync(registryPath, 'utf-8')
+    entries = JSON.parse(content) as RegistryEntry[]
+  })
+
+  it('is valid JSON and non-empty', () => {
+    expect(entries.length).toBeGreaterThan(0)
+  })
+
+  it('every entry has required fields', () => {
+    for (const e of entries) {
+      expect(e.name).toBeTruthy()
+      expect(e.displayName).toBeTruthy()
+      expect(e.description).toBeTruthy()
+      expect(e.type).toBeTruthy()
+      expect(e.languages).toBeInstanceOf(Array)
+      expect(e.categories).toBeInstanceOf(Array)
+      expect(e.convert).toBeInstanceOf(Array)
+      expect(e.convert.length).toBeGreaterThan(0)
+    }
+  })
+
+  it('every entry has valid type', () => {
+    const validTypes = ['ts-bridge', 'pure-lsp', 'direct-api', 'snippets', 'lsp']
+    for (const e of entries) {
+      expect(validTypes).toContain(e.type)
+    }
+  })
+
+  it('every entry has valid source', () => {
+    const validSourceTypes = ['github', 'npm']
+    for (const e of entries) {
+      expect(validSourceTypes).toContain(e.source.type)
+      if (e.source.type === 'github') {
+        expect(e.source.repo).toBeTruthy()
+      } else if (e.source.type === 'npm') {
+        expect(e.source.package).toBeTruthy()
+      }
+    }
+  })
+
+  it('every convert step has a known type', () => {
+    const knownStepTypes = ['source', 'language-client', 'bridge', 'snippets', 'mark-unsupported']
+    for (const e of entries) {
+      for (const step of e.convert) {
+        expect(knownStepTypes).toContain(step.type)
+      }
+    }
+  })
+
+  it('language-server steps have valid server config', () => {
+    for (const e of entries) {
+      for (const step of e.convert) {
+        if (step.type === 'language-client') {
+          expect(step.server).toBeTruthy()
+          expect(['module', 'binary']).toContain(step.server.kind)
+          expect(step.server.package).toBeTruthy()
+          expect(step.languages).toBeInstanceOf(Array)
+        }
+      }
+    }
+  })
+
+  it('snippets entries have type "snippets"', () => {
+    const snippetsEntries = entries.filter(e => e.convert.some(s => s.type === 'snippets'))
+    for (const e of snippetsEntries) {
+      expect(e.type).toBe('snippets')
+    }
+  })
+
+  it('no duplicate names', () => {
+    const names = entries.map(e => e.name)
+    const unique = new Set(names)
+    expect(unique.size).toBe(names.length)
+  })
+
+  it('descriptions are non-empty', () => {
+    for (const e of entries) {
+      expect(e.description.length).toBeGreaterThan(0)
+    }
+  })
+
+  it('every entry has at least one language', () => {
+    for (const e of entries) {
+      expect(e.languages.length).toBeGreaterThan(0)
+    }
+  })
+
+  it('minPluginVersion is valid semver if present', () => {
+    const semverRe = /^\d+\.\d+\.\d+/
+    for (const e of entries) {
+      if (e.minPluginVersion) {
+        expect(e.minPluginVersion).toMatch(semverRe)
+      }
+    }
+  })
+
+  it('bridge entries have bridge step with preset', () => {
+    const bridgeEntries = entries.filter(e => e.type === 'ts-bridge')
+    for (const e of bridgeEntries) {
+      const bridgeStep = e.convert.find(s => s.type === 'bridge')
+      expect(bridgeStep).toBeTruthy()
+      expect(bridgeStep!.preset).toBeTruthy()
+    }
+  })
+})

package/converter/src/scanner.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from 'vitest'
+import * as path from 'path'
+import * as fs from 'fs'
+import * as os from 'os'
+
+describe('scanner', () => {
+  it('returns empty result for missing directory', async () => {
+    const { scan } = await import('./scanner.js')
+    const result = scan('/nonexistent/path')
+    expect(result.files).toHaveLength(0)
+    expect(result.summary).toContain('no source directory')
+  })
+
+  it('detects vscode imports in .ts files', async () => {
+    const tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), 'scanner-test-'))
+    fs.writeFileSync(path.join(tmpdir, 'ext.ts'), "import * as vscode from 'vscode'")
+    const { scan } = await import('./scanner.js')
+    const result = scan(tmpdir)
+    expect(result.files).toHaveLength(1)
+    expect(result.files[0].apis).toContain('vscode')
+    expect(result.summary).toContain('1 files')
+    fs.rmSync(tmpdir, { recursive: true, force: true })
+  })
+
+  it('detects require("vscode") in .ts files', async () => {
+    const tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), 'scanner-test-'))
+    fs.writeFileSync(path.join(tmpdir, 'ext.ts'), "const vscode = require('vscode')")
+    const { scan } = await import('./scanner.js')
+    const result = scan(tmpdir)
+    expect(result.files).toHaveLength(1)
+    expect(result.files[0].apis).toContain('vscode')
+    fs.rmSync(tmpdir, { recursive: true, force: true })
+  })
+
+  it('detects vscode imports in .js files', async () => {
+    const tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), 'scanner-test-'))
+    fs.writeFileSync(path.join(tmpdir, 'ext.js'), "const vscode = require('vscode')")
+    const { scan } = await import('./scanner.js')
+    const result = scan(tmpdir)
+    expect(result.files).toHaveLength(1)
+    expect(result.files[0].apis).toContain('vscode')
+    fs.rmSync(tmpdir, { recursive: true, force: true })
+  })
+
+  it('recurses into subdirectories', async () => {
+    const tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), 'scanner-test-'))
+    fs.mkdirSync(path.join(tmpdir, 'sub'))
+    fs.writeFileSync(path.join(tmpdir, 'sub', 'ext.ts'), "import * as vscode from 'vscode'")
+    const { scan } = await import('./scanner.js')
+    const result = scan(tmpdir)
+    expect(result.files).toHaveLength(1)
+    expect(result.files[0].path).toContain('sub')
+    fs.rmSync(tmpdir, { recursive: true, force: true })
+  })
+
+  it('skips node_modules and dot dirs', async () => {
+    const tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), 'scanner-test-'))
+    fs.mkdirSync(path.join(tmpdir, 'node_modules'), { recursive: true })
+    fs.writeFileSync(path.join(tmpdir, 'node_modules', 'ext.ts'), "import * as vscode from 'vscode'")
+    fs.mkdirSync(path.join(tmpdir, '.git'), { recursive: true })
+    fs.writeFileSync(path.join(tmpdir, '.git', 'ext.ts'), "import * as vscode from 'vscode'")
+    const { scan } = await import('./scanner.js')
+    const result = scan(tmpdir)
+    expect(result.files).toHaveLength(0)
+    fs.rmSync(tmpdir, { recursive: true, force: true })
+  })
+})

package/converter/src/scanner.ts

@@ -16,7 +16,7 @@ export function scan(dir: string): ScanResult {
   if (!fs.existsSync(dir)) {
     return { files, summary: 'no source directory found' }
   }
-  const tsFiles = walk(dir).filter(f => f.endsWith('.ts') || f.endsWith('.tsx'))
+  const tsFiles = walk(dir).filter(f => f.endsWith('.ts') || f.endsWith('.tsx') || f.endsWith('.js'))
 
   for (const filePath of tsFiles) {
     const content = fs.readFileSync(filePath, 'utf-8')

package/converter/src/steps/bridge.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect } from 'vitest'
+
+describe('bridge step', () => {
+  it('throws on unknown preset', async () => {
+    const { bridgeGenerator } = await import('./bridge.js')
+    expect(() => {
+      bridgeGenerator.generate(
+        { input: '/fake', output: '/fake/out', origPkg: {}, project: null as any, presets: {} },
+        { type: 'bridge', preset: 'nonexistent' },
+      )
+    }).toThrow('Unknown bridge preset')
+  })
+
+  it('throws on empty type without preset', async () => {
+    const { bridgeGenerator } = await import('./bridge.js')
+    expect(() => {
+      bridgeGenerator.generate(
+        { input: '/fake', output: '/fake/out', origPkg: {}, project: null as any },
+        { type: 'bridge', options: {} },
+      )
+    }).toThrow('Unknown bridge type')
+  })
+
+  it('generates tsserver-forward bridge with preset', async () => {
+    const { bridgeGenerator } = await import('./bridge.js')
+    const result = bridgeGenerator.generate(
+      {
+        input: '/fake',
+        output: '/fake/out',
+        origPkg: { name: 'test', dependencies: { typescript: '^5.0.0' } },
+        project: null as any,
+        presets: {
+          'ts-bridge': {
+            type: 'tsserver-forward',
+            options: { extensions: ['vue'], services: ['typescript'] },
+          },
+        },
+      },
+      { type: 'bridge', preset: 'ts-bridge' },
+    )
+
+    expect(result.generatedFiles).toHaveLength(1)
+    expect(result.generatedFiles[0].path).toBe('src/bridge.ts')
+    expect(result.generatedFiles[0].content).toContain('registerBridge')
+    expect(result.generatedFiles[0].content).toContain('tsserver/request')
+
+    expect(result.keepDeps).toHaveProperty('typescript')
+    expect(result.keepDeps.typescript).toBe('^5.0.0')
+
+    expect(result.codeInjections).toBeDefined()
+    expect(result.codeInjections!.length).toBeGreaterThan(0)
+    expect(result.codeInjections![0].target).toBe('src/index.ts')
+  })
+
+  it('includes verbose logging when enabled', async () => {
+    const { bridgeGenerator } = await import('./bridge.js')
+    const result = bridgeGenerator.generate(
+      {
+        input: '/fake',
+        output: '/fake/out',
+        origPkg: { name: 'test', dependencies: { typescript: '*' } },
+        project: null as any,
+        presets: { 'ts-bridge': { type: 'tsserver-forward' } },
+      },
+      { type: 'bridge', preset: 'ts-bridge', options: {}, verbose: true },
+    )
+
+    const code = result.generatedFiles[0].content
+    expect(code).toContain('[bridge] registerBridge called')
+    expect(code).toContain('[bridge] client ready')
+  })
+})

package/converter/src/steps/language-client.test.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect } from 'vitest'
+
+describe('language-client step', () => {
+  it('generates valid index.ts for module-kind server', async () => {
+    const { languageClientGenerator } = await import('./language-client.js')
+    const result = languageClientGenerator.generate(
+      {
+        input: '/fake',
+        output: '/fake/out',
+        origPkg: { name: 'test-ls', description: 'Test LS' },
+        project: null as any,
+      },
+      {
+        type: 'language-client',
+        server: { kind: 'module', package: 'test-language-server', entry: 'main' },
+        languages: ['test'],
+      },
+    )
+
+    expect(result.entryPoint).toBe('src/index.ts')
+    expect(result.generatedFiles).toHaveLength(1)
+    expect(result.generatedFiles[0].path).toBe('src/index.ts')
+
+    const code = result.generatedFiles[0].content
+    expect(code).toContain('LanguageClient')
+    expect(code).toContain("from 'coc.nvim'")
+    expect(code).toContain('test-language-server')
+    expect(code).toContain('activate')
+    expect(code).toContain('context.subscriptions.push')
+  })
+
+  it('generates binary server download code for binary-kind server', async () => {
+    const { languageClientGenerator } = await import('./language-client.js')
+    const result = languageClientGenerator.generate(
+      {
+        input: '/fake',
+        output: '/fake/out',
+        origPkg: { name: 'binary-ls', description: 'Binary LS' },
+        project: null as any,
+      },
+      {
+        type: 'language-client',
+        server: {
+          kind: 'binary',
+          package: 'my-server',
+          binary: { repo: 'user/repo', asset: 'server-{{version}}-{{platform}}-{{arch}}.tar.gz', binaryPath: 'bin/server' },
+        },
+        languages: ['test'],
+      },
+    )
+
+    // Binary config is stored in result.serverBinary, not embedded in code
+    expect(result.serverBinary).toBeTruthy()
+    expect(result.serverBinary!.repo).toBe('user/repo')
+
+    const code = result.generatedFiles[0].content
+    expect(code).toContain('LanguageClient')
+    expect(code).toContain("from 'coc.nvim'")
+    expect(code).toContain('require.resolve')
+    expect(code).toContain("'bin/server'")
+  })
+
+  it('generates stdio transport for binary kind', async () => {
+    const { languageClientGenerator } = await import('./language-client.js')
+    const result = languageClientGenerator.generate(
+      {
+        input: '/fake',
+        output: '/fake/out',
+        origPkg: { name: 'stdio-ls' },
+        project: null as any,
+      },
+      {
+        type: 'language-client',
+        server: { kind: 'binary', package: 'bin-ls', binary: { repo: 'user/repo', asset: 'bin-{{version}}.tar.gz' } },
+        languages: ['test'],
+        transport: 'stdio',
+      },
+    )
+
+    const code = result.generatedFiles[0].content
+    // Binary kind with stdio uses command: serverPath (Executable options), not module+TransportKind
+    // TransportKind is only used for module kind where { module, transport } is set
+    expect(code).toContain("command: serverPath")
+    expect(code).not.toContain('TransportKind.ipc')
+  })
+
+  it('includes initializationOptions when configured', async () => {
+    const { languageClientGenerator } = await import('./language-client.js')
+    const result = languageClientGenerator.generate(
+      {
+        input: '/fake',
+        output: '/fake/out',
+        origPkg: { name: 'init-ls' },
+        project: null as any,
+      },
+      {
+        type: 'language-client',
+        server: { kind: 'module', package: 'init-ls-server' },
+        languages: ['test'],
+        initializationOptions: '{ typescript: { tsdk: serverPath } }',
+      },
+    )
+
+    const code = result.generatedFiles[0].content
+    expect(code).toContain('initializationOptions')
+    expect(code).toContain('tsdk: serverPath')
+  })
+
+  it('uses custom id for LanguageClient name', async () => {
+    const { languageClientGenerator } = await import('./language-client.js')
+    const result = languageClientGenerator.generate(
+      {
+        input: '/fake',
+        output: '/fake/out',
+        origPkg: { name: 'default-name' },
+        project: null as any,
+      },
+      {
+        type: 'language-client',
+        id: 'my-custom-id',
+        server: { kind: 'module', package: 'some-server' },
+        languages: ['test'],
+      },
+    )
+
+    const code = result.generatedFiles[0].content
+    expect(code).toContain("'my-custom-id'")
+    // The description/command still use origPkg name, only the id is custom
+    expect(code).toContain("'default-name'")
+  })
+})

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

@@ -93,7 +93,7 @@ import * as path from 'path'
 export async function activate(context: ExtensionContext): Promise<void> {
   try {
 ${ls.verbose ? `    console.log('[${escapeStr(id)}] activate() called')\n` : ''}${serverPathCode}
-    if (!serverPath) {
+    if (!serverPath && !_mainEntry) {
 ${ls.verbose ? `    console.log('[${escapeStr(id)}] serverPath undefined')\n` : ''}\
       window.showErrorMessage('Cannot find language server.')
       return

package/converter/src/steps/mark-unsupported.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import * as path from 'path'
+import * as os from 'os'
+import * as fs from 'fs'
+
+describe('mark-unsupported step', () => {
+  let tmpdir: string
+
+  beforeEach(() => {
+    tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), 'mark-unsup-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpdir, { recursive: true, force: true })
+  })
+
+  function writeSrc(rel: string, content: string) {
+    const fp = path.join(tmpdir, 'src', rel)
+    fs.mkdirSync(path.dirname(fp), { recursive: true })
+    fs.writeFileSync(fp, content)
+  }
+
+  it('comments out createTextEditorDecorationType calls', async () => {
+    writeSrc('ext.ts', 'editor.createTextEditorDecorationType({})')
+    const { markUnsupportedGenerator } = await import('./mark-unsupported.js')
+    markUnsupportedGenerator.generate(
+      { input: tmpdir, output: tmpdir, origPkg: {}, project: null as any },
+      { type: 'mark-unsupported', features: ['decoration'] },
+    )
+    const content = fs.readFileSync(path.join(tmpdir, 'src', 'ext.ts'), 'utf-8')
+    expect(content).toContain('TODO: Decoration API is not supported')
+    expect(content).toContain('void 0')
+  })
+
+  it('comments out setDecorations calls', async () => {
+    writeSrc('ext.ts', 'editor.setDecorations(dec, ranges)')
+    const { markUnsupportedGenerator } = await import('./mark-unsupported.js')
+    markUnsupportedGenerator.generate(
+      { input: tmpdir, output: tmpdir, origPkg: {}, project: null as any },
+      { type: 'mark-unsupported', features: ['decoration'] },
+    )
+    const content = fs.readFileSync(path.join(tmpdir, 'src', 'ext.ts'), 'utf-8')
+    expect(content).toContain('TODO: Decoration API is not supported')
+  })
+
+  it('comments out createWebviewPanel calls', async () => {
+    writeSrc('ext.ts', 'const panel = window.createWebviewPanel("view", "title", viewColumn)')
+    const { markUnsupportedGenerator } = await import('./mark-unsupported.js')
+    markUnsupportedGenerator.generate(
+      { input: tmpdir, output: tmpdir, origPkg: {}, project: null as any },
+      { type: 'mark-unsupported', features: ['webview'] },
+    )
+    const content = fs.readFileSync(path.join(tmpdir, 'src', 'ext.ts'), 'utf-8')
+    expect(content).toContain('TODO: Webview API is not supported')
+  })
+
+  it('comments out registerTreeDataProvider calls', async () => {
+    writeSrc('ext.ts', 'window.registerTreeDataProvider("view", provider)')
+    const { markUnsupportedGenerator } = await import('./mark-unsupported.js')
+    markUnsupportedGenerator.generate(
+      { input: tmpdir, output: tmpdir, origPkg: {}, project: null as any },
+      { type: 'mark-unsupported', features: ['tree-data-provider'] },
+    )
+    const content = fs.readFileSync(path.join(tmpdir, 'src', 'ext.ts'), 'utf-8')
+    expect(content).toContain('TODO: Tree data provider is not supported')
+  })
+
+  it('comments out env.openExternal calls', async () => {
+    writeSrc('ext.ts', 'env.openExternal(url)')
+    const { markUnsupportedGenerator } = await import('./mark-unsupported.js')
+    markUnsupportedGenerator.generate(
+      { input: tmpdir, output: tmpdir, origPkg: {}, project: null as any },
+      { type: 'mark-unsupported', features: ['open-external'] },
+    )
+    const content = fs.readFileSync(path.join(tmpdir, 'src', 'ext.ts'), 'utf-8')
+    expect(content).toContain('TODO: env.openExternal has no equivalent')
+  })
+
+  it('handles unknown feature gracefully', async () => {
+    writeSrc('ext.ts', 'const x = 1')
+    const { markUnsupportedGenerator } = await import('./mark-unsupported.js')
+    const result = markUnsupportedGenerator.generate(
+      { input: tmpdir, output: tmpdir, origPkg: {}, project: null as any },
+      { type: 'mark-unsupported', features: ['nonexistent'] },
+    )
+    expect(result.generatedFiles).toEqual([])
+  })
+
+  it('handles missing src directory', async () => {
+    const outdir = tmpdir + '/out'
+    const { markUnsupportedGenerator } = await import('./mark-unsupported.js')
+    const result = markUnsupportedGenerator.generate(
+      { input: tmpdir, output: outdir, origPkg: {}, project: null as any },
+      { type: 'mark-unsupported', features: ['decoration'] },
+    )
+    expect(result.generatedFiles).toEqual([])
+  })
+
+  it('only processes .ts files', async () => {
+    writeSrc('ext.js', 'editor.setDecorations(dec, ranges)')
+    const { markUnsupportedGenerator } = await import('./mark-unsupported.js')
+    markUnsupportedGenerator.generate(
+      { input: tmpdir, output: tmpdir, origPkg: {}, project: null as any },
+      { type: 'mark-unsupported', features: ['decoration'] },
+    )
+    const content = fs.readFileSync(path.join(tmpdir, 'src', 'ext.js'), 'utf-8')
+    expect(content).not.toContain('TODO')
+  })
+})

package/converter/src/steps/snippets.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import * as path from 'path'
+import * as os from 'os'
+import * as fs from 'fs'
+
+describe('snippets step', () => {
+  let tmpdir: string
+
+  beforeEach(() => {
+    tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), 'snippets-test-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpdir, { recursive: true, force: true })
+  })
+
+  function writeFile(relPath: string, content: string) {
+    const fp = path.join(tmpdir, relPath)
+    fs.mkdirSync(path.dirname(fp), { recursive: true })
+    fs.writeFileSync(fp, content)
+  }
+
+  it('detects missing contributes.snippets in source and throws', async () => {
+    const { snippetsGenerator } = await import('./snippets.js')
+    expect(() => {
+      snippetsGenerator.generate(
+        { input: tmpdir, output: tmpdir + '/out', origPkg: {}, project: null as any },
+        { type: 'snippets' },
+      )
+    }).toThrow('has no contributes.snippets')
+  })
+
+  it('copies snippet files and generates index.ts', async () => {
+    writeFile('snippets/javascript.json', JSON.stringify({ "console.log": { "prefix": "log", "body": "console.log($1)" } }))
+    writeFile('snippets/typescript.json', JSON.stringify({ "console.log": { "prefix": "log", "body": "console.log($1)" } }))
+    const outdir = tmpdir + '/out'
+    const { snippetsGenerator } = await import('./snippets.js')
+    const result = snippetsGenerator.generate(
+      {
+        input: tmpdir,
+        output: outdir,
+        origPkg: {
+          contributes: {
+            snippets: [
+              { language: 'javascript', path: './snippets/javascript.json' },
+              { language: 'typescript', path: './snippets/typescript.json' },
+            ],
+          },
+        },
+        project: null as any,
+      },
+      { type: 'snippets' },
+    )
+
+    expect(result.generatedFiles).toHaveLength(1)
+    expect(result.generatedFiles[0].path).toBe('src/index.ts')
+    expect(result.generatedFiles[0].content).toContain('activate')
+    expect(result.generatedFiles[0].content).toContain('coc.nvim')
+
+    expect(result.activationEvents).toContain('onLanguage:javascript')
+    expect(result.activationEvents).toContain('onLanguage:typescript')
+
+    expect(fs.existsSync(path.join(outdir, 'snippets/javascript.json'))).toBe(true)
+    expect(fs.existsSync(path.join(outdir, 'snippets/typescript.json'))).toBe(true)
+  })
+
+  it('uses languages override when specified', async () => {
+    writeFile('snippets/javascript.json', JSON.stringify({ test: { prefix: 't', body: 'test' } }))
+    writeFile('snippets/vue.json', JSON.stringify({ test: { prefix: 't', body: 'test' } }))
+    const outdir = tmpdir + '/out'
+    const { snippetsGenerator } = await import('./snippets.js')
+    const result = snippetsGenerator.generate(
+      {
+        input: tmpdir,
+        output: outdir,
+        origPkg: {
+          contributes: {
+            snippets: [
+              { language: 'javascript', path: './snippets/javascript.json' },
+              { language: 'vue', path: './snippets/vue.json' },
+            ],
+          },
+        },
+        project: null as any,
+      },
+      { type: 'snippets', languages: ['javascript'] },
+    )
+
+    expect(result.activationEvents).toEqual(['onLanguage:javascript'])
+    expect(fs.existsSync(path.join(outdir, 'snippets/vue.json'))).toBe(false)
+  })
+
+  it('throws when no snippet files are found', async () => {
+    const outdir = tmpdir + '/out'
+    const { snippetsGenerator } = await import('./snippets.js')
+    expect(() => {
+      snippetsGenerator.generate(
+        {
+          input: tmpdir,
+          output: outdir,
+          origPkg: {
+            contributes: {
+              snippets: [
+                { language: 'javascript', path: './snippets/javascript.json' },
+              ],
+            },
+          },
+          project: null as any,
+        },
+        { type: 'snippets' },
+      )
+    }).toThrow('no snippet files were copied')
+  })
+})