feat: special command: removeFunctionArgumentsTypesInSelection

Author: zardoy

package.json

@@ -11,6 +11,11 @@
                 "command": "enableStrictEmmetInJsx",
                 "title": "Enable Strict Emmet in JSX",
                 "category": "TS Essentials JSX"
+            },
+            {
+                "command": "removeFunctionArgumentsTypesInSelection",
+                "title": "Remove Function Arguments Types in Selection",
+                "category": "TS Essentials"
             }
         ],
         "typescriptServerPlugins": [

src/extension.ts

@@ -12,6 +12,7 @@ import migrateSettings from './migrateSettings'
 import figIntegration from './figIntegration'
 import apiCommands from './apiCommands'
 import onCompletionAccepted from './onCompletionAccepted'
+import specialCommands from './specialCommands'
 
 export const activateTsPlugin = (tsApi: { configurePlugin; onCompletionAccepted }) => {
     let webWaitingForConfigSync = false
@@ -66,6 +67,7 @@ export const activateTsPlugin = (tsApi: { configurePlugin; onCompletionAccepted
     void registerEmmet()
     webImports()
     apiCommands()
+    specialCommands()
 
     figIntegration()
 }

src/sendCommand.ts

@@ -6,11 +6,16 @@ import { TriggerCharacterCommand } from '../typescript/src/ipcTypes'
 type SendCommandData = {
     position: vscode.Position
     document: vscode.TextDocument
+    inputOptions?: any
 }
 export const sendCommand = async <T>(command: TriggerCharacterCommand, sendCommandDataArg?: SendCommandData): Promise<T | undefined> => {
     // plugin id disabled, languageService would not understand the special trigger character
     if (!getExtensionSetting('enablePlugin')) return
 
+    if (sendCommandDataArg?.inputOptions) {
+        command = `${command}?${JSON.stringify(sendCommandDataArg.inputOptions)}` as any
+    }
+
     const {
         document: { uri },
         position,

src/specialCommands.ts

@@ -0,0 +1,35 @@
+import * as vscode from 'vscode'
+import { getActiveRegularEditor } from '@zardoy/vscode-utils'
+import { registerExtensionCommand } from 'vscode-framework'
+import { RequestOptionsTypes, RequestResponseTypes } from '../typescript/src/ipcTypes'
+import { sendCommand } from './sendCommand'
+
+export default () => {
+    registerExtensionCommand('removeFunctionArgumentsTypesInSelection', async () => {
+        const editor = getActiveRegularEditor()
+        if (!editor) return
+        const { selection, document } = editor
+        const response = await sendCommand<RequestResponseTypes['removeFunctionArgumentsTypesInSelection']>('removeFunctionArgumentsTypesInSelection', {
+            document,
+            position: selection.start,
+            inputOptions: {
+                endSelection: document.offsetAt(selection.end),
+            } as RequestOptionsTypes['removeFunctionArgumentsTypesInSelection'],
+        })
+        if (!response) return
+        const { ranges } = response
+        void editor.edit(builder => {
+            for (const [start, end] of ranges) {
+                builder.delete(new vscode.Range(document.positionAt(start), document.positionAt(end)))
+            }
+        })
+    })
+
+    registerExtensionCommand('pickAndInsertFunctionArguments', async () => {
+        const editor = getActiveRegularEditor()
+        if (!editor) return
+        const result = await sendCommand<RequestResponseTypes['pickAndInsertFunctionArguments']>('pickAndInsertFunctionArguments')
+        if (!result) return
+        result.functions
+    })
+}

typescript/src/ipcTypes.ts

@@ -1,6 +1,13 @@
 export const passthroughExposedApiCommands = ['getNodePath', 'getSpanOfEnclosingComment', 'getNodeAtPosition'] as const
 
-export const triggerCharacterCommands = [...passthroughExposedApiCommands, 'emmet-completions', 'getPostfixes'] as const
+export const triggerCharacterCommands = [
+    ...passthroughExposedApiCommands,
+    'emmet-completions',
+    'getPostfixes',
+    'filterBySyntaxKind',
+    'removeFunctionArgumentsTypesInSelection',
+    'pickAndInsertFunctionArguments',
+] as const
 
 export type TriggerCharacterCommand = typeof triggerCharacterCommands[number]
 
@@ -10,6 +17,21 @@ export type NodeAtPositionResponse = {
     end: number
 }
 
+export type RequestResponseTypes = {
+    removeFunctionArgumentsTypesInSelection: {
+        ranges: [number, number][]
+    }
+    pickAndInsertFunctionArguments: {
+        functions: string[]
+    }
+}
+
+export type RequestOptionsTypes = {
+    removeFunctionArgumentsTypesInSelection: {
+        endSelection: number
+    }
+}
+
 // export type EmmetResult = {
 //     label: string
 //     documentation: any

typescript/src/specialCommands/handle.ts

@@ -1,5 +1,5 @@
 import postfixesAtPosition from '../completions/postfixesAtPosition'
-import { NodeAtPositionResponse, TriggerCharacterCommand, triggerCharacterCommands } from '../ipcTypes'
+import { NodeAtPositionResponse, RequestOptionsTypes, TriggerCharacterCommand, triggerCharacterCommands } from '../ipcTypes'
 import { findChildContainingPosition, getNodePath } from '../utils'
 import getEmmetCompletions from './emmet'
 
@@ -14,6 +14,9 @@ export default (
     entries: []
     typescriptEssentialsResponse: any
 } => {
+    const _specialCommandsParts = specialCommand.split('?')
+    specialCommand = _specialCommandsParts[0]! as TriggerCharacterCommand
+    const specialCommandArg = _specialCommandsParts[1] && JSON.parse(_specialCommandsParts[1])
     if (triggerCharacterCommands.includes(specialCommand) && !configuration) {
         throw new Error('no-ts-essential-plugin-configuration')
     }
@@ -54,8 +57,31 @@ export default (
             typescriptEssentialsResponse: postfixesAtPosition(position, fileName, scriptSnapshot, info.languageService),
         } as any
     }
+    if (specialCommand === 'removeFunctionArgumentsTypesInSelection') {
+        changeType<RequestOptionsTypes['removeFunctionArgumentsTypesInSelection']>(specialCommandArg)
+
+        const node = findChildContainingPosition(ts, sourceFile, position)
+        if (!node) return
+        if (!ts.isIdentifier(node) || !node.parent || !ts.isParameter(node.parent) || !node.parent.parent?.parameters) {
+            return
+        }
+        const allParams = node.parent.parent.parameters
+        return {
+            entries: [],
+            typescriptEssentialsResponse: {
+                ranges: allParams
+                    .map(param => {
+                        if (!param.type || param.name.pos > specialCommandArg.endSelection) return
+                        return [param.name.end, param.type.end]
+                    })
+                    .filter(Boolean),
+            },
+        }
+    }
 }
 
+function changeType<T>(arg): asserts arg is T {}
+
 function nodeToApiResponse(node: ts.Node): NodeAtPositionResponse {
     return {
         kindName: ts.SyntaxKind[node.kind]!,