Merge pull request #95 from zardoy/develop

Author: zardoy

src/configurationType.ts

@@ -249,15 +249,6 @@ export type Configuration = {
      * @default false
      */
     'jsxImproveElementsSuggestions.filterNamespaces': boolean
-    /**
-     * @default false
-     */
-    'experimentalPostfixes.enable': boolean
-    /**
-     * Disable specific postfixes from this plugin
-     * @default []
-     */
-    'experimentalPostfixes.disablePostfixes': string[]
     /**
      * Requires TS server restart
      * @default false

src/experimentalPostfixes.ts

@@ -1,13 +1,13 @@
 /* eslint-disable @typescript-eslint/no-require-imports */
 import * as vscode from 'vscode'
 import { defaultJsSupersetLangs } from '@zardoy/vscode-utils/build/langs'
-import { extensionCtx, getExtensionSettingId } from 'vscode-framework'
+import { extensionCtx, getExtensionSetting, getExtensionSettingId } from 'vscode-framework'
 import { pickObj } from '@zardoy/utils'
+import { watchExtensionSettings } from '@zardoy/vscode-utils/build/settings'
 import { Configuration } from './configurationType'
 import webImports from './webImports'
 import { sendCommand } from './sendCommand'
 import { registerEmmet } from './emmet'
-import experimentalPostfixes from './experimentalPostfixes'
 import migrateSettings from './migrateSettings'
 import figIntegration from './figIntegration'
 import apiCommands from './apiCommands'
@@ -16,13 +16,21 @@ import specialCommands from './specialCommands'
 import vueVolarSupport from './vueVolarSupport'
 import moreCompletions from './moreCompletions'
 
-export const activateTsPlugin = (tsApi: { configurePlugin; onCompletionAccepted }) => {
+let isActivated = false
+// let erroredStatusBarItem: vscode.StatusBarItem | undefined
+
+export const activateTsPlugin = (tsApi: { configurePlugin; onCompletionAccepted } | undefined) => {
+    if (isActivated) return
+    isActivated = true
     let webWaitingForConfigSync = false
 
     const syncConfig = () => {
+        if (!tsApi) return
         console.log('sending configure request for typescript-essential-plugins')
         const config = vscode.workspace.getConfiguration().get(process.env.IDS_PREFIX!)
 
+        tsApi.configurePlugin('typescript-essential-plugins', config)
+
         if (process.env.PLATFORM === 'node') {
             // see comment in plugin
             require('fs').writeFileSync(
@@ -31,8 +39,6 @@ export const activateTsPlugin = (tsApi: { configurePlugin; onCompletionAccepted
             )
         }
 
-        tsApi.configurePlugin('typescript-essential-plugins', config)
-
         if (process.env.PLATFORM === 'web') {
             webWaitingForConfigSync = true
         }
@@ -49,7 +55,7 @@ export const activateTsPlugin = (tsApi: { configurePlugin; onCompletionAccepted
     })
     syncConfig()
 
-    onCompletionAccepted(tsApi)
+    if (tsApi) onCompletionAccepted(tsApi)
 
     if (process.env.PLATFORM === 'web') {
         const possiblySyncConfig = async () => {
@@ -65,7 +71,6 @@ export const activateTsPlugin = (tsApi: { configurePlugin; onCompletionAccepted
         void possiblySyncConfig()
     }
 
-    experimentalPostfixes()
     moreCompletions()
     void registerEmmet()
     webImports()
@@ -81,24 +86,47 @@ export const activate = async () => {
 
     const possiblyActivateTsPlugin = async () => {
         const tsExtension = vscode.extensions.getExtension('vscode.typescript-language-features')
-        if (!tsExtension) return
+        if (tsExtension) {
+            await tsExtension.activate()
+
+            if (!tsExtension.exports || !tsExtension.exports.getAPI) {
+                throw new Error("TS extension doesn't export API")
+            }
+
+            // Get the API from the TS extension
+            const api = tsExtension.exports.getAPI(0)
+            if (!api) {
+                throw new Error("TS extension doesn't have API")
+            }
 
-        await tsExtension.activate()
+            activateTsPlugin(api)
+            return true
+        }
 
-        if (!tsExtension.exports || !tsExtension.exports.getAPI) return
+        if (vscode.extensions.getExtension('Vue.volar') && getExtensionSetting('enableVueSupport')) {
+            activateTsPlugin(undefined)
+            return true
+        }
 
-        // Get the API from the TS extension
-        const api = tsExtension.exports.getAPI(0)
-        if (!api) return
-        activateTsPlugin(api)
-        return true
+        return false
     }
 
     const isActivated = (await possiblyActivateTsPlugin()) ?? false
     if (!isActivated) {
-        // can be also used in future, for now only when activating TS extension manually
-        const { dispose } = vscode.extensions.onDidChange(async () => {
-            if (await possiblyActivateTsPlugin()) dispose()
+        // can be also used in future, for now only when activating TS or Volar extension manually
+        const disposables = []
+        const { dispose } = vscode.extensions.onDidChange(
+            async () => {
+                if (await possiblyActivateTsPlugin()) dispose()
+            },
+            undefined,
+            disposables,
+        )
+        watchExtensionSettings(['enableVueSupport'], async () => {
+            if (await possiblyActivateTsPlugin()) {
+                // todo
+                // disposables.forEach(d => d.dispose())
+            }
         })
     }
 }

src/extension.ts

@@ -6,20 +6,20 @@ export default () => {
         defaultJsSupersetLangsWithVue,
         {
             provideCompletionItems(document, position, token, context) {
-                const regex = /\/\/@?[\w-]*/
+                const regex = /\/\/ ?@?[\w-]*/
                 let range = document.getWordRangeAtPosition(position, regex)
                 if (!range) return
                 const rangeText = document.getText(range)
                 if (rangeText !== document.lineAt(position).text.trim()) {
                     return
                 }
 
-                range = range.with(range.start.translate(0, 2), range.end)
+                range = range.with(range.start.translate(0, rangeText.indexOf('@')), range.end)
                 const tsDirectives = ['@ts-format-ignore-line', '@ts-format-ignore-region', '@ts-format-ignore-endregion']
                 return tsDirectives.map((directive, i) => {
                     const completionItem = new vscode.CompletionItem(directive, vscode.CompletionItemKind.Snippet)
                     completionItem.range = range
-                    completionItem.sortText = `z${i}`
+                    completionItem.sortText = `@z${i}`
                     return completionItem
                 })
             },

src/moreCompletions.ts

@@ -1,7 +1,7 @@
 import * as vscode from 'vscode'
 import { getActiveRegularEditor } from '@zardoy/vscode-utils'
 import { getExtensionSetting } from 'vscode-framework'
-import { TriggerCharacterCommand } from '../typescript/src/ipcTypes'
+import { passthroughExposedApiCommands, TriggerCharacterCommand } from '../typescript/src/ipcTypes'
 
 type SendCommandData<K> = {
     position: vscode.Position
@@ -10,7 +10,22 @@ type SendCommandData<K> = {
 }
 export const sendCommand = async <T, K = any>(command: TriggerCharacterCommand, sendCommandDataArg?: SendCommandData<K>): Promise<T | undefined> => {
     // plugin id disabled, languageService would not understand the special trigger character
-    if (!getExtensionSetting('enablePlugin')) return
+    if (!getExtensionSetting('enablePlugin')) {
+        console.warn('Ignoring request because plugin is disabled')
+        return
+    }
+
+    if (!vscode.extensions.getExtension('vscode.typescript-language-features')) {
+        const message = 'Special commands are not supported in Volar takeover mode'
+        if (passthroughExposedApiCommands.includes(command as any)) {
+            // don't spam in case of api command
+            console.error(message)
+        } else {
+            throw new Error(message)
+        }
+
+        return
+    }
 
     if (sendCommandDataArg?.inputOptions) {
         command = `${command}?${JSON.stringify(sendCommandDataArg.inputOptions)}` as any

src/sendCommand.ts

@@ -2,7 +2,7 @@ import _ from 'lodash'
 import addMissingProperties from './codeFixes/addMissingProperties'
 import { changeSortingOfAutoImport, getIgnoreAutoImportSetting, isAutoImportEntryShouldBeIgnored } from './adjustAutoImports'
 import { GetConfig } from './types'
-import { findChildContainingPosition, getIndentFromPos } from './utils'
+import { findChildContainingPosition, getIndentFromPos, patchMethod } from './utils'
 
 // codeFixes that I managed to put in files
 const externalCodeFixes = [addMissingProperties]
@@ -166,31 +166,41 @@ export default (proxy: ts.LanguageService, languageService: ts.LanguageService,
             const ignoreAutoImportsSetting = getIgnoreAutoImportSetting(c)
             for (const diagnostic of semanticDiagnostics) {
                 if (!errorCodes.includes(diagnostic.code)) continue
-                const oldFirst = tsFull.first
-                const oldForEachExternalModuleToImportFrom = tsFull.forEachExternalModuleToImportFrom
+                const toUnpatch: (() => any)[] = []
                 try {
-                    tsFull.first = ((fixes: FixInfo[]) => {
-                        const sortFn = changeSortingOfAutoImport(c, fixes[0]!.symbolName)
-                        fixes = _.sortBy(
-                            fixes.filter(({ fix, symbolName }) => {
-                                if (fix.kind === (ImportFixKind.PromoteTypeOnly as number)) return false
-                                const shouldBeIgnored =
-                                    c('autoImport.alwaysIgnoreInImportAll').includes(fix.moduleSpecifier) ||
-                                    isAutoImportEntryShouldBeIgnored(ignoreAutoImportsSetting, fix.moduleSpecifier, symbolName)
-                                return !shouldBeIgnored
-                            }),
-                            ({ fix }) => sortFn(fix.moduleSpecifier),
-                        )
-                        return fixes[0]
-                    }) as any
-                    // patching is fun
-                    tsFull.forEachExternalModuleToImportFrom = (program, host, preferences, _useAutoImportProvider, cb) => {
-                        return oldForEachExternalModuleToImportFrom(program, host, preferences, true, cb)
-                    }
+                    toUnpatch.push(
+                        patchMethod(
+                            tsFull,
+                            'first',
+                            () =>
+                                ((fixes: FixInfo[]) => {
+                                    const sortFn = changeSortingOfAutoImport(c, fixes[0]!.symbolName)
+                                    fixes = _.sortBy(
+                                        fixes.filter(({ fix, symbolName }) => {
+                                            if (fix.kind === (ImportFixKind.PromoteTypeOnly as number)) return false
+                                            const shouldBeIgnored =
+                                                c('autoImport.alwaysIgnoreInImportAll').includes(fix.moduleSpecifier) ||
+                                                isAutoImportEntryShouldBeIgnored(ignoreAutoImportsSetting, fix.moduleSpecifier, symbolName)
+                                            return !shouldBeIgnored
+                                        }),
+                                        ({ fix }) => sortFn(fix.moduleSpecifier),
+                                    )
+                                    return fixes[0]
+                                }) as any,
+                        ),
+                        patchMethod(
+                            tsFull,
+                            'forEachExternalModuleToImportFrom',
+                            oldForEachExternalModuleToImportFrom => (program, host, preferences, _useAutoImportProvider, cb) => {
+                                return oldForEachExternalModuleToImportFrom(program, host, preferences, true, cb)
+                            },
+                        ),
+                    )
                     importAdder.addImportFromDiagnostic({ ...diagnostic, file: sourceFile as any } as any, context)
                 } finally {
-                    tsFull.first = oldFirst
-                    tsFull.forEachExternalModuleToImportFrom = oldForEachExternalModuleToImportFrom
+                    for (const unpatch of toUnpatch) {
+                        unpatch()
+                    }
                 }
             }
             return tsFull.codefix.createCombinedCodeActions(tsFull.textChanges.ChangeTracker.with(context, importAdder.writeFixes))