feat: New code action! *Swap Keys and Values in Object*

Author: zardoy

README.MD

@@ -2,9 +2,11 @@
 
 ## Top Features
 
-### Special Commands
+> Here React experience hits different!
 
-See [special commands list](#special-commands-list)
+### Special Commands & Actions
+
+See [special commands list](#special-commands-list) ans [code actions list](#contributed-code-actions)
 
 ### JSX Outline
 
@@ -154,6 +156,26 @@ type A<T extends 'foo' | 'bar' = ''> = ...
 
 Use cases: search excluding comments, search & replace only within strings, find interested JSX attribute node
 
+## Contributed Code Actions
+
+### Swap Keys and Values in Object
+
+> *Note*: Code action displayed **only** when object is fully explicitly selected
+
+Example:
+
+```ts
+const obj = {
+    key1: 'someValue',
+    key2: getSuperUniqueKey()
+}
+// turns into
+const obj = {
+    'someValue': 'key1',
+    [getSuperUniqueKey()]: 'key2'
+}
+```
+
 ## Even Even More
 
 Please look at extension settings, as this extension has much more features than described here!

typescript/src/codeActions/decorateProxy.ts

@@ -9,7 +9,7 @@ export default (proxy: ts.LanguageService, languageService: ts.LanguageService,
 
         const program = languageService.getProgram()
         const sourceFile = program!.getSourceFile(fileName)!
-        const { info: refactorInfo } = getCodeActions(ts, sourceFile, positionOrRange)
+        const { info: refactorInfo } = getCodeActions(sourceFile, positionOrRange)
         if (refactorInfo) prior = [...prior, refactorInfo]
 
         return prior
@@ -20,7 +20,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(ts, sourceFile, positionOrRange, actionName)
+            const { edit } = getCodeActions(sourceFile, positionOrRange, actionName)
             return edit
         }
         return languageService.getEditsForRefactor(fileName, formatOptions, positionOrRange, refactorName, actionName, preferences)

typescript/src/codeActions/getCodeActions.ts

@@ -1,5 +1,6 @@
 import { compact } from '@zardoy/utils'
-import type tslib from 'typescript/lib/tsserverlibrary'
+import { findChildContainingPosition } from '../utils'
+import objectSwapKeysAndValues from './objectSwapKeysAndValues'
 import toggleBraces from './toggleBraces'
 
 type SimplifiedRefactorInfo = {
@@ -9,10 +10,10 @@ type SimplifiedRefactorInfo = {
 }
 
 export type ApplyCodeAction = (
-    ts: typeof tslib,
     sourceFile: ts.SourceFile,
     position: number,
-    range?: ts.TextRange,
+    range: ts.TextRange | undefined,
+    node: ts.Node | undefined,
 ) => ts.RefactorEditInfo | SimplifiedRefactorInfo[] | undefined
 
 export type CodeAction = {
@@ -21,22 +22,21 @@ export type CodeAction = {
     tryToApply: ApplyCodeAction
 }
 
-const codeActions: CodeAction[] = [
-    /* toggleBraces */
-]
+const codeActions: CodeAction[] = [/* toggleBraces */ objectSwapKeysAndValues]
 
 export const REFACTORS_CATEGORY = 'essential-refactors'
 
 export default (
-    ts: typeof tslib,
     sourceFile: ts.SourceFile,
     positionOrRange: ts.TextRange | number,
     requestingEditsId?: string,
 ): { info?: ts.ApplicableRefactorInfo; edit: ts.RefactorEditInfo } => {
     const range = typeof positionOrRange !== 'number' && positionOrRange.pos !== positionOrRange.end ? positionOrRange : undefined
+    const pos = typeof positionOrRange === 'number' ? positionOrRange : positionOrRange.pos
+    const node = findChildContainingPosition(ts, sourceFile, pos)
     const appliableCodeActions = compact(
         codeActions.map(action => {
-            const edits = action.tryToApply(ts, sourceFile, typeof positionOrRange === 'number' ? positionOrRange : positionOrRange.pos, range)
+            const edits = action.tryToApply(sourceFile, pos, range, node)
             if (!edits) return
             return {
                 ...action,

typescript/src/codeActions/objectSwapKeysAndValues.ts

@@ -0,0 +1,69 @@
+import { approveCast } from '../utils'
+import { CodeAction } from './getCodeActions'
+
+const nodeToSpan = (node: ts.Node): ts.TextSpan => {
+    const start = node.pos + (node.getLeadingTriviaWidth() ?? 0)
+    return { start, length: node.end - start }
+}
+
+export default {
+    id: 'objectSwapKeysAndValues',
+    name: 'Swap Keys and Values in Object',
+    tryToApply(sourceFile, _position, range, node) {
+        if (!range || !node) return
+        // requires full explicit object selection (be aware of comma) to not be annoying with suggestion
+        if (!approveCast(node, ts.isObjectLiteralExpression) || !(range.pos === node.pos + node.getLeadingTriviaWidth() && range.end === node.end)) return
+        const edits: ts.TextChange[] = []
+        for (const property of node.properties) {
+            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}]`
+            }
+            edits.push({
+                newText: initializerText,
+                span: nodeToSpan(name),
+            })
+            edits.push({
+                newText: ts.isComputedPropertyName(name)
+                    ? name.expression.getText()
+                    : ts.isIdentifier(name)
+                    ? /* TODO quote preference */ `'${name.text}'`
+                    : name.getText(),
+                span: nodeToSpan(initializer),
+            })
+        }
+        if (!edits.length) return undefined
+        return {
+            edits: [
+                {
+                    fileName: sourceFile.fileName,
+                    textChanges: edits,
+                },
+            ],
+        }
+    },
+} satisfies CodeAction
+
+// TODO!
+if (import.meta.vitest) {
+    const { it, expect } = import.meta.vitest
+    it('objectSwapKeysAndValues', () => {
+        const case1 = /* ts */ `
+            const a = /*1*/{
+                // description
+                test: /*inline comment?*/ 3,
+                /** */['test2']: getComputedStyle.apply(),
+                'test2': 'someValue'
+            }/*2*/
+        `
+    })
+}

typescript/src/globals.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="vitest/importMeta" />
 import('ts-expose-internals')
 // prvided by esbuild at top-level of bundle in buildTsPlugin.mjs
 declare let ts: typeof import('typescript')

typescript/src/utils.ts

@@ -170,8 +170,10 @@ const wordRangeAtPos = (text: string, position: number) => {
     return text.slice(startPos + 1, endPos)
 }
 
-export function approveCast<TOut extends TIn, TIn = any>(value: TIn | undefined, test: (value: TIn) => value is TOut): value is TOut
-export function approveCast<T>(value: T, test: (value: T) => boolean): T | undefined
-export function approveCast<T>(value: T, test: (value: T) => boolean): T | undefined {
-    return value !== undefined && test(value) ? value : undefined
+type GetIs<T> = T extends (elem: any) => elem is infer T ? T : never
+
+export function approveCast<T2 extends Array<(node: ts.Node) => node is ts.Node>>(node: ts.Node | undefined, ...oneOfTest: T2): node is GetIs<T2[number]> {
+    if (node === undefined) return false
+    if (!oneOfTest) throw new Error('Tests are not provided')
+    return oneOfTest.some(test => test(node))
 }