preview: add move to existing file code action (refactoring)

also refactor two step refactorings to general interfrace

Author: zardoy

src/specialCommands.ts

@@ -2,13 +2,14 @@ import * as vscode from 'vscode'
 import { getActiveRegularEditor } from '@zardoy/vscode-utils'
 import { getExtensionCommandId, getExtensionSetting, registerExtensionCommand, VSCodeQuickPickItem } from 'vscode-framework'
 import { showQuickPick } from '@zardoy/vscode-utils/build/quickPick'
-import _ from 'lodash'
+import _, { partition } from 'lodash'
 import { compact } from '@zardoy/utils'
 import { defaultJsSupersetLangsWithVue } from '@zardoy/vscode-utils/build/langs'
 import { offsetPosition } from '@zardoy/vscode-utils/build/position'
+import { relative, join } from 'path-browserify'
 import { RequestOptionsTypes, RequestResponseTypes } from '../typescript/src/ipcTypes'
 import { sendCommand } from './sendCommand'
-import { tsRangeToVscode, tsRangeToVscodeSelection, tsTextChangesToVcodeTextEdits } from './util'
+import { getTsLikePath, pickFileWithQuickPick, tsRangeToVscode, tsRangeToVscodeSelection, tsTextChangesToVcodeTextEdits } from './util'
 
 export default () => {
     registerExtensionCommand('removeFunctionArgumentsTypesInSelection', async () => {
@@ -221,49 +222,29 @@ export default () => {
         await vscode.commands.executeCommand(getExtensionCommandId('goToNodeBySyntaxKind'), { filterWithSelection: true })
     })
 
-    async function sendTurnIntoArrayRequest<T = RequestResponseTypes['turnArrayIntoObject']>(
-        range: vscode.Range,
-        selectedKeyName?: string,
-        document = vscode.window.activeTextEditor!.document,
-    ) {
-        return sendCommand<T, RequestOptionsTypes['turnArrayIntoObject']>('turnArrayIntoObject', {
+    async function getPossibleTwoStepRefactorings(range: vscode.Range, document = vscode.window.activeTextEditor!.document) {
+        return sendCommand<RequestResponseTypes['getTwoStepCodeActions'], RequestOptionsTypes['getTwoStepCodeActions']>('getTwoStepCodeActions', {
             document,
             position: range.start,
             inputOptions: {
                 range: [document.offsetAt(range.start), document.offsetAt(range.end)] as [number, number],
-                selectedKeyName,
             },
         })
     }
 
-    registerExtensionCommand('turnArrayIntoObjectRefactoring' as any, async (_, arg?: RequestResponseTypes['turnArrayIntoObject']) => {
-        if (!arg) return
-        const { keysCount, totalCount, totalObjectCount } = arg
-        const selectedKey: string | false | undefined =
-            // eslint-disable-next-line @typescript-eslint/dot-notation
-            arg['key'] ||
-            (await showQuickPick(
-                Object.entries(keysCount).map(([key, count]) => {
-                    const isAllowed = count === totalObjectCount
-                    return { label: `${isAllowed ? '$(check)' : '$(close)'}${key}`, value: isAllowed ? key : false, description: `${count} hits` }
-                }),
-                {
-                    title: `Selected available key from ${totalObjectCount} objects (${totalCount} elements)`,
+    async function getSecondStepRefactoringData(range: vscode.Range, secondStepData?: any, document = vscode.window.activeTextEditor!.document) {
+        return sendCommand<RequestResponseTypes['twoStepCodeActionSecondStep'], RequestOptionsTypes['twoStepCodeActionSecondStep']>(
+            'twoStepCodeActionSecondStep',
+            {
+                document,
+                position: range.start,
+                inputOptions: {
+                    range: [document.offsetAt(range.start), document.offsetAt(range.end)] as [number, number],
+                    data: secondStepData,
                 },
-            ))
-        if (selectedKey === undefined || selectedKey === '') return
-        if (selectedKey === false) {
-            void vscode.window.showWarningMessage("Can't use selected key as its not used in every object")
-            return
-        }
-
-        const editor = vscode.window.activeTextEditor!
-        const edits = await sendTurnIntoArrayRequest<RequestResponseTypes['turnArrayIntoObjectEdit']>(editor.selection, selectedKey)
-        if (!edits) throw new Error('Unknown error. Try debug.')
-        const edit = new vscode.WorkspaceEdit()
-        edit.set(editor.document.uri, tsTextChangesToVcodeTextEdits(editor.document, edits))
-        await vscode.workspace.applyEdit(edit)
-    })
+            },
+        )
+    }
 
     registerExtensionCommand('acceptRenameWithParams' as any, async (_, { preview = false, comments = null, strings = null, alias = null } = {}) => {
         const editor = vscode.window.activeTextEditor
@@ -284,7 +265,90 @@ export default () => {
         await vscode.commands.executeCommand(preview ? 'acceptRenameInputWithPreview' : 'acceptRenameInput')
     })
 
-    // its actually a code action, but will be removed from there soon
+    // #region two-steps code actions
+    registerExtensionCommand('applyRefactor' as any, async (_, arg?: RequestResponseTypes['getTwoStepCodeActions']) => {
+        if (!arg) return
+        let sendNextData: RequestOptionsTypes['twoStepCodeActionSecondStep']['data'] | undefined
+        const { turnArrayIntoObject, moveToExistingFile } = arg
+        if (turnArrayIntoObject) {
+            const { keysCount, totalCount, totalObjectCount } = turnArrayIntoObject
+            const selectedKey = await showQuickPick(
+                Object.entries(keysCount).map(([key, count]) => {
+                    const isAllowed = count === totalObjectCount
+                    return { label: `${isAllowed ? '$(check)' : '$(close)'}${key}`, value: isAllowed ? key : false, description: `${count} hits` }
+                }),
+                {
+                    title: `Selected available key from ${totalObjectCount} objects (${totalCount} elements)`,
+                },
+            )
+            if (selectedKey === undefined || selectedKey === '') return
+            if (selectedKey === false) {
+                void vscode.window.showWarningMessage("Can't use selected key as its not used in object of every element")
+                return
+            }
+
+            sendNextData = {
+                name: 'turnArrayIntoObject',
+                selectedKeyName: selectedKey as string,
+            }
+        }
+
+        if (moveToExistingFile) {
+            sendNextData = {
+                name: 'moveToExistingFile',
+            }
+        }
+
+        if (!sendNextData) return
+        const editor = vscode.window.activeTextEditor!
+        const nextResponse = await getSecondStepRefactoringData(editor.selection, sendNextData)
+        if (!nextResponse) throw new Error('No code action data. Try debug.')
+        const edit = new vscode.WorkspaceEdit()
+        let mainChanges = 'edits' in nextResponse && nextResponse.edits
+        if (moveToExistingFile && 'fileNames' in nextResponse) {
+            const { fileNames, fileEdits } = nextResponse
+            const selectedFilePath = await pickFileWithQuickPick(fileNames)
+            if (!selectedFilePath) return
+            const document = await vscode.workspace.openTextDocument(vscode.Uri.file(selectedFilePath))
+            const outline = await vscode.commands.executeCommand('vscode.executeDocumentSymbolProvider', document.uri)
+            const currentEditorPath = getTsLikePath(vscode.window.activeTextEditor!.document.uri)
+            // currently ignoring other files due to https://github.com/microsoft/TypeScript/issues/32344
+            // TODO-high it ignores any updates in https://github.com/microsoft/TypeScript/blob/20182cf8485ca5cf360d9396ad25d939b848a0ec/src/services/refactors/moveToNewFile.ts#L290
+            const currentFileEdits = [...fileEdits.find(fileEdit => fileEdit.fileName === currentEditorPath)!.textChanges]
+            const textChangeIndexToPatch = currentFileEdits.findIndex(currentFileEdit => currentFileEdit.newText.trim())
+            const { newText: updateImportText } = currentFileEdits[textChangeIndexToPatch]!
+            // TODO-mid use native path resolver (ext, index, alias)
+            let newRelativePath = relative(join(currentEditorPath, '..'), selectedFilePath)
+            if (!newRelativePath.startsWith('./') && !newRelativePath.startsWith('../')) newRelativePath = `./${newRelativePath}`
+            currentFileEdits[textChangeIndexToPatch]!.newText = updateImportText.replace(/(['"]).+(['"])/, (_m, g1) => `${g1}${newRelativePath}${g1}`)
+            mainChanges = currentFileEdits
+            const newFileText = fileEdits.find(fileEdit => fileEdit.isNewFile)!.textChanges[0]!.newText
+            const [importLines, otherLines] = partition(newFileText.split('\n'), line => line.startsWith('import '))
+            const startPos = new vscode.Position(0, 0)
+            const newFileNodes = await sendCommand<RequestResponseTypes['filterBySyntaxKind']>('filterBySyntaxKind', {
+                position: startPos,
+                document,
+            })
+            const lastImportDeclaration = newFileNodes?.nodesByKind.ImportDeclaration?.at(-1)
+            const lastImportEnd = lastImportDeclaration ? tsRangeToVscode(document, lastImportDeclaration.range).end : startPos
+            edit.set(vscode.Uri.file(selectedFilePath), [
+                {
+                    range: new vscode.Range(startPos, startPos),
+                    newText: [...importLines, '\n'].join('\n'),
+                },
+                {
+                    range: new vscode.Range(lastImportEnd, lastImportEnd),
+                    newText: ['\n', ...otherLines].join('\n'),
+                },
+            ])
+        }
+
+        if (!mainChanges) return
+        edit.set(editor.document.uri, tsTextChangesToVcodeTextEdits(editor.document, mainChanges))
+        await vscode.workspace.applyEdit(edit)
+    })
+
+    // most probably will be moved to ts-code-actions extension
     vscode.languages.registerCodeActionsProvider(defaultJsSupersetLangsWithVue, {
         async provideCodeActions(document, range, context, token) {
             if (document !== vscode.window.activeTextEditor?.document || !getExtensionSetting('enablePlugin')) {
@@ -301,22 +365,34 @@ export default () => {
             }
 
             if (context.triggerKind !== vscode.CodeActionTriggerKind.Invoke) return
-            const result = await sendTurnIntoArrayRequest(range)
+            const result = await getPossibleTwoStepRefactorings(range)
             if (!result) return
-            const { keysCount, totalCount, totalObjectCount } = result
-            return [
-                {
-                    title: `Turn Array Into Object (${totalCount} elements)`,
-                    command: getExtensionCommandId('turnArrayIntoObjectRefactoring' as any),
-                    arguments: [
-                        {
-                            keysCount,
-                            totalCount,
-                            totalObjectCount,
-                        } satisfies RequestResponseTypes['turnArrayIntoObject'],
-                    ],
-                },
-            ]
+            const { turnArrayIntoObject, moveToExistingFile } = result
+            const codeActions: vscode.CodeAction[] = []
+            const getCommand = (arg): vscode.Command | undefined => ({
+                title: '',
+                command: getExtensionCommandId('applyRefactor' as any),
+                arguments: [arg],
+            })
+
+            if (turnArrayIntoObject) {
+                codeActions.push({
+                    title: `Turn array into object (${turnArrayIntoObject.totalCount} elements)`,
+                    command: getCommand({ turnArrayIntoObject }),
+                    kind: vscode.CodeActionKind.RefactorRewrite,
+                })
+            }
+
+            if (moveToExistingFile) {
+                codeActions.push({
+                    title: `Move to existing file`,
+                    command: getCommand({ moveToExistingFile }),
+                    kind: vscode.CodeActionKind.Refactor.append('move'),
+                })
+            }
+
+            return codeActions
         },
     })
+    // #endregion
 }

src/util.ts

@@ -1,5 +1,10 @@
 import * as vscode from 'vscode'
 import { offsetPosition } from '@zardoy/vscode-utils/build/position'
+import { showQuickPick } from '@zardoy/vscode-utils/build/quickPick'
+import { Utils } from 'vscode-uri'
+import { relative, join } from 'path-browserify'
+
+const normalizeWindowPath = (path: string | undefined) => path?.replace(/\\/g, '/')
 
 export const tsRangeToVscode = (document: vscode.TextDocument, [start, end]: [number, number]) =>
     new vscode.Range(document.positionAt(start), document.positionAt(end))
@@ -15,3 +20,48 @@ export const tsTextChangesToVcodeTextEdits = (document: vscode.TextDocument, edi
             newText,
         }
     })
+
+export const getTsLikePath = <T extends vscode.Uri | undefined>(uri: T): T extends undefined ? undefined : string =>
+    uri && (normalizeWindowPath(uri.fsPath) as any)
+
+// pick other file
+export const pickFileWithQuickPick = async (fileNames: string[], optionsOverride?) => {
+    const editorUri = vscode.window.activeTextEditor?.document.uri
+    const editorFilePath = editorUri?.fsPath && getTsLikePath(editorUri)
+    if (editorFilePath) fileNames = fileNames.filter(fileName => fileName !== editorFilePath)
+    const currentWorkspacePath = editorUri && getTsLikePath(vscode.workspace.getWorkspaceFolder(editorUri)?.uri)
+    const getItems = (filter?: string) => {
+        const filterFilePath = filter && editorUri ? getTsLikePath(Utils.joinPath(editorUri, '..', filter)) : undefined
+        const filtered = fileNames.filter(fileName => (filterFilePath ? fileName.startsWith(filterFilePath) : true))
+        const relativePath = filterFilePath ? join(filterFilePath, '..') : currentWorkspacePath
+        return filtered.map(fileName => {
+            let label = relativePath ? relative(relativePath, fileName) : fileName
+            if (filterFilePath && !label.startsWith('./') && !label.startsWith('../')) label = `./${label}`
+            return {
+                label,
+                value: fileName,
+                alwaysShow: !!filterFilePath,
+                buttons: [
+                    {
+                        iconPath: new vscode.ThemeIcon('go-to-file'),
+                        tooltip: 'Open file',
+                    },
+                ],
+            }
+        })
+    }
+
+    const selectedFile = await showQuickPick(getItems(), {
+        title: 'Select file',
+        onDidChangeValue(text) {
+            this.items = ['../', './'].some(p => text.startsWith(p)) ? getItems(text) : getItems()
+        },
+        onDidTriggerItemButton(button) {
+            if (button.button.tooltip === 'Open file') {
+                void vscode.window.showTextDocument(vscode.Uri.file(button.item.value))
+            }
+        },
+        ...optionsOverride,
+    })
+    return selectedFile
+}

typescript/src/codeActions/decorateProxy.ts

@@ -1,12 +1,22 @@
+import { compact } from '@zardoy/utils'
+import { previousGetCodeActionsResult } from '../specialCommands/handle'
 import { GetConfig } from '../types'
 import { handleFunctionRefactorEdits, processApplicableRefactors } from './functionExtractors'
-import getCodeActions, { REFACTORS_CATEGORY } from './getCodeActions'
+import getCustomCodeActions, { REFACTORS_CATEGORY } from './getCodeActions'
 import improveBuiltin from './improveBuiltin'
 
 export default (proxy: ts.LanguageService, languageService: ts.LanguageService, languageServiceHost: ts.LanguageServiceHost, c: GetConfig) => {
     proxy.getApplicableRefactors = (fileName, positionOrRange, preferences) => {
         let prior = languageService.getApplicableRefactors(fileName, positionOrRange, preferences)
 
+        previousGetCodeActionsResult.value = compact(
+            prior.flatMap(refactor => {
+                const actions = refactor.actions.filter(action => !action.notApplicableReason).map(action => action.description)
+                if (!actions.length) return
+                return actions.map(action => ({ description: refactor.description, name: action }))
+            }),
+        )
+
         const program = languageService.getProgram()!
         const sourceFile = program.getSourceFile(fileName)!
         processApplicableRefactors(
@@ -18,7 +28,7 @@ export default (proxy: ts.LanguageService, languageService: ts.LanguageService,
 
         if (c('markTsCodeActions.enable')) prior = prior.map(item => ({ ...item, description: `🔵 ${item.description}` }))
 
-        const { info: refactorInfo } = getCodeActions(sourceFile, positionOrRange, languageService, languageServiceHost)
+        const { info: refactorInfo } = getCustomCodeActions(sourceFile, positionOrRange, languageService, languageServiceHost)
         if (refactorInfo) prior = [...prior, refactorInfo]
 
         return prior
@@ -29,7 +39,7 @@ export default (proxy: ts.LanguageService, languageService: ts.LanguageService,
         if (category === REFACTORS_CATEGORY) {
             const program = languageService.getProgram()
             const sourceFile = program!.getSourceFile(fileName)!
-            const { edit } = getCodeActions(sourceFile, positionOrRange, languageService, languageServiceHost, formatOptions, actionName)
+            const { edit } = getCustomCodeActions(sourceFile, positionOrRange, languageService, languageServiceHost, formatOptions, actionName)
             return edit
         }
         if (refactorName === 'Extract Symbol' && actionName.startsWith('function_scope')) {

typescript/src/codeActions/getCodeActions.ts

@@ -2,7 +2,6 @@ import { compact } from '@zardoy/utils'
 import { findChildContainingPosition } from '../utils'
 import objectSwapKeysAndValues from './custom/objectSwapKeysAndValues'
 import changeStringReplaceToRegex from './custom/changeStringReplaceToRegex'
-import splitDeclarationAndInitialization from './custom/splitDeclarationAndInitialization'
 
 type SimplifiedRefactorInfo =
     | {
@@ -31,7 +30,7 @@ export type CodeAction = {
     tryToApply: ApplyCodeAction
 }
 
-const codeActions: CodeAction[] = [/* toggleBraces */ objectSwapKeysAndValues, changeStringReplaceToRegex, splitDeclarationAndInitialization]
+const codeActions: CodeAction[] = [/* toggleBraces */ objectSwapKeysAndValues, changeStringReplaceToRegex]
 
 export const REFACTORS_CATEGORY = 'essential-refactors'
 

typescript/src/completions/keywordsSpace.ts

@@ -40,7 +40,7 @@ export default (entries: ts.CompletionEntry[], scriptSnapshot: ts.IScriptSnapsho
     })
 }
 
-const isTypeNode = (node: ts.Node) => {
+export const isTypeNode = (node: ts.Node) => {
     if (ts.isTypeNode(node)) {
         // built-in types
         return true