feat: New code action (another refactoring): *Turn Array Into Object*. Its huge!

zardoy · zardoy · commit d61f9be9fab4 · 2022-12-16T03:54:18.000+03:00
diff --git a/README.MD b/README.MD
@@ -176,6 +176,39 @@ const obj = {
 }
 ```
 
+### Turn Array Into Object
+
+```ts
+const data = [
+    {
+        // test
+        key: 'bar',
+        a: 0
+    },
+    {
+        key: 'baz',
+        // yes
+        b: 1
+    }
+]
+```
+
+After selecting code action, you'll get asked for key to used (here you can use only `key`) and after applying:
+
+```ts
+const a = {
+    'bar': {
+        a: 0
+    },
+    'baz': {
+        // yes
+        b: 1
+    }
+}
+```
+
+(note that for now refactoring removes properties with comments!)
+
 ## Even Even More
 
 Please look at extension settings, as this extension has much more features than described here!
diff --git a/src/sendCommand.ts b/src/sendCommand.ts
@@ -3,12 +3,12 @@ import { getActiveRegularEditor } from '@zardoy/vscode-utils'
 import { getExtensionSetting } from 'vscode-framework'
 import { TriggerCharacterCommand } from '../typescript/src/ipcTypes'
 
-type SendCommandData = {
+type SendCommandData<K> = {
     position: vscode.Position
     document: vscode.TextDocument
-    inputOptions?: any
+    inputOptions?: K
 }
-export const sendCommand = async <T>(command: TriggerCharacterCommand, sendCommandDataArg?: SendCommandData): Promise<T | undefined> => {
+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
 
@@ -19,7 +19,7 @@ export const sendCommand = async <T>(command: TriggerCharacterCommand, sendComma
     const {
         document: { uri },
         position,
-    } = ((): SendCommandData => {
+    } = ((): SendCommandData<any> => {
         if (sendCommandDataArg) return sendCommandDataArg
         const editor = getActiveRegularEditor()!
         return {
diff --git a/src/specialCommands.ts b/src/specialCommands.ts
@@ -1,9 +1,11 @@
 import * as vscode from 'vscode'
-import { getActiveRegularEditor, rangeToSelection } from '@zardoy/vscode-utils'
+import { getActiveRegularEditor } from '@zardoy/vscode-utils'
 import { getExtensionCommandId, registerExtensionCommand, VSCodeQuickPickItem } from 'vscode-framework'
 import { showQuickPick } from '@zardoy/vscode-utils/build/quickPick'
 import _ from 'lodash'
 import { compact } from '@zardoy/utils'
+import { defaultJsSupersetLangsWithVue } from '@zardoy/vscode-utils/build/langs'
+import { offsetPosition } from '@zardoy/vscode-utils/build/position'
 import { RequestOptionsTypes, RequestResponseTypes } from '../typescript/src/ipcTypes'
 import { sendCommand } from './sendCommand'
 import { tsRangeToVscode, tsRangeToVscodeSelection } from './util'
@@ -13,12 +15,15 @@ export default () => {
         const editor = getActiveRegularEditor()
         if (!editor) return
         const { selection, document } = editor
-        const response = await sendCommand<RequestResponseTypes['removeFunctionArgumentsTypesInSelection']>('removeFunctionArgumentsTypesInSelection', {
+        const response = await sendCommand<
+            RequestResponseTypes['removeFunctionArgumentsTypesInSelection'],
+            RequestOptionsTypes['removeFunctionArgumentsTypesInSelection']
+        >('removeFunctionArgumentsTypesInSelection', {
             document,
             position: selection.start,
             inputOptions: {
                 endSelection: document.offsetAt(selection.end),
-            } as RequestOptionsTypes['removeFunctionArgumentsTypesInSelection'],
+            },
         })
         if (!response) return
         const { ranges } = response
@@ -215,4 +220,74 @@ export default () => {
     registerExtensionCommand('goToNodeBySyntaxKindWithinSelection', async () => {
         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', {
+            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)`,
+                },
+            ))
+        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.')
+        await editor.edit(builder => {
+            for (const { span, newText } of edits) {
+                const start = editor.document.positionAt(span.start)
+                builder.replace(new vscode.Range(start, offsetPosition(editor.document, start, span.length)), newText)
+            }
+        })
+    })
+
+    // its actually a code action, but will be removed from there soon
+    vscode.languages.registerCodeActionsProvider(defaultJsSupersetLangsWithVue, {
+        async provideCodeActions(document, range, context, token) {
+            if (context.triggerKind !== vscode.CodeActionTriggerKind.Invoke || document !== vscode.window.activeTextEditor?.document) return
+            const result = await sendTurnIntoArrayRequest(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'],
+                    ],
+                },
+            ]
+        },
+    })
 }
diff --git a/typescript/src/codeActions/getCodeActions.ts b/typescript/src/codeActions/getCodeActions.ts
@@ -3,11 +3,13 @@ import { findChildContainingPosition } from '../utils'
 import objectSwapKeysAndValues from './objectSwapKeysAndValues'
 import toggleBraces from './toggleBraces'
 
-type SimplifiedRefactorInfo = {
-    start: number
-    length: number
-    newText: string
-}
+type SimplifiedRefactorInfo =
+    | {
+          start: number
+          length: number
+          newText: string
+      }
+    | ts.TextChange[]
 
 export type ApplyCodeAction = (
     sourceFile: ts.SourceFile,
@@ -45,14 +47,18 @@ export default (
                           edits: [
                               {
                                   fileName: sourceFile.fileName,
-                                  textChanges: edits.map(({ length, newText, start }) => {
-                                      return {
-                                          newText,
-                                          span: {
-                                              length,
-                                              start,
-                                          },
+                                  textChanges: edits.map(change => {
+                                      if ('start' in change) {
+                                          const { newText, start, length } = change
+                                          return {
+                                              newText,
+                                              span: {
+                                                  length,
+                                                  start,
+                                              },
+                                          }
                                       }
+                                      return change
                                   }),
                               },
                           ],
diff --git a/typescript/src/codeActions/objectSwapKeysAndValues.ts b/typescript/src/codeActions/objectSwapKeysAndValues.ts
@@ -6,6 +6,20 @@ const nodeToSpan = (node: ts.Node): ts.TextSpan => {
     return { start, length: node.end - start }
 }
 
+export const printNodeForObjectKey = (node: ts.Node) => {
+    const needsComputedBraces = approveCast(node, ts.isStringLiteral, ts.isNumericLiteral)
+        ? false
+        : approveCast(node, ts.isIdentifier, ts.isCallExpression, ts.isPropertyAccessExpression)
+        ? true
+        : undefined
+    if (needsComputedBraces === undefined) return
+    let nodeText = node.getText()
+    if (needsComputedBraces) {
+        nodeText = `[${nodeText}]`
+    }
+    return nodeText
+}
+
 export default {
     id: 'objectSwapKeysAndValues',
     name: 'Swap Keys and Values in Object',
@@ -18,16 +32,8 @@ export default {
             if (!ts.isPropertyAssignment(property)) continue
             const { name, initializer } = property
             if (!name || ts.isPrivateIdentifier(name)) continue
-            const needsComputedBraces = approveCast(initializer, ts.isStringLiteral, ts.isNumericLiteral)
-                ? false
-                : approveCast(initializer, ts.isIdentifier, ts.isCallExpression, ts.isPropertyAccessExpression)
-                ? true
-                : undefined
-            if (needsComputedBraces === undefined) continue
-            let initializerText = initializer.getText()
-            if (needsComputedBraces) {
-                initializerText = `[${initializerText}]`
-            }
+            const initializerText = printNodeForObjectKey(initializer)
+            if (!initializerText) continue
             edits.push({
                 newText: initializerText,
                 span: nodeToSpan(name),
diff --git a/typescript/src/ipcTypes.ts b/typescript/src/ipcTypes.ts
@@ -8,6 +8,7 @@ export const triggerCharacterCommands = [
     'removeFunctionArgumentsTypesInSelection',
     'pickAndInsertFunctionArguments',
     'getRangeOfSpecialValue',
+    'turnArrayIntoObject',
 ] as const
 
 export type TriggerCharacterCommand = typeof triggerCharacterCommands[number]
@@ -22,6 +23,9 @@ type TsRange = [number, number]
 
 export type PickFunctionArgsType = [name: string, declaration: TsRange, args: [name: string, type: string][]]
 
+/**
+ * @keysSuggestions TriggerCharacterCommand
+ */
 export type RequestResponseTypes = {
     removeFunctionArgumentsTypesInSelection: {
         ranges: TsRange[]
@@ -35,12 +39,22 @@ export type RequestResponseTypes = {
     filterBySyntaxKind: {
         nodesByKind: Record<string, Array<{ range: TsRange }>>
     }
+    turnArrayIntoObject: {
+        keysCount: Record<string, number>
+        totalCount: number
+        totalObjectCount: number
+    }
+    turnArrayIntoObjectEdit: ts.TextChange[]
 }
 
 export type RequestOptionsTypes = {
     removeFunctionArgumentsTypesInSelection: {
         endSelection: number
     }
+    turnArrayIntoObject: {
+        range: [number, number]
+        selectedKeyName?: string
+    }
 }
 
 // export type EmmetResult = {
diff --git a/typescript/src/specialCommands/handle.ts b/typescript/src/specialCommands/handle.ts
diff --git a/typescript/src/specialCommands/objectIntoArrayConverters.ts b/typescript/src/specialCommands/objectIntoArrayConverters.ts
