feat(preview): Improve builtin extract to type / interface code actions to infer extracted type name from linked indentifier name. Disabled by default for now.

Author: zardoy

src/configurationType.ts

@@ -448,6 +448,16 @@ export type Configuration = {
      * @default false
      */
     displayAdditionalInfoInCompletions: boolean
+    /**
+     * Wether to try to infer name for extract type / interface code action
+     * e.g. `let foo: { a: number }` -> `type FooType = { a: number }`
+     *
+     * Experimental and *will be enabled by default* once its:
+     * 1. More configurable and rename is called
+     * 2. Logic to avoid name conflicts
+     * @default false
+     */
+    'codeActions.extractTypeInferName': boolean
 }
 
 // scrapped using search editor. config: caseInsesetive, context lines: 0, regex: const fix\w+ = "[^ ]+"

typescript/src/codeActions/decorateProxy.ts

@@ -1,5 +1,6 @@
 import { GetConfig } from '../types'
 import getCodeActions, { REFACTORS_CATEGORY } from './getCodeActions'
+import improveBuiltin from './improveBuiltin'
 
 export default (proxy: ts.LanguageService, languageService: ts.LanguageService, c: GetConfig) => {
     proxy.getApplicableRefactors = (fileName, positionOrRange, preferences) => {
@@ -23,6 +24,8 @@ export default (proxy: ts.LanguageService, languageService: ts.LanguageService,
             const { edit } = getCodeActions(sourceFile, positionOrRange, actionName)
             return edit
         }
-        return languageService.getEditsForRefactor(fileName, formatOptions, positionOrRange, refactorName, actionName, preferences)
+        const prior = languageService.getEditsForRefactor(fileName, formatOptions, positionOrRange, refactorName, actionName, preferences)
+        if (!prior) return
+        return improveBuiltin(fileName, refactorName, actionName, languageService, c, prior) ?? prior
     }
 }

typescript/src/codeActions/improveBuiltin.ts

@@ -0,0 +1,49 @@
+import { GetConfig } from '../types'
+import { findChildContainingExactPosition } from '../utils'
+
+export default (
+    fileName: string,
+    refactorName: string,
+    actionName: string,
+    languageService: ts.LanguageService,
+    c: GetConfig,
+    prior: ts.RefactorEditInfo,
+): ts.RefactorEditInfo | undefined => {
+    const extractToInterface = actionName === 'Extract to interface'
+    if (c('codeActions.extractTypeInferName') && (actionName === 'Extract to type alias' || extractToInterface)) {
+        const changeFirstEdit = (oldText: string, newTypeName: string) => {
+            const startMarker = extractToInterface ? 'interface ' : 'type '
+            const endMarker = extractToInterface ? ' {' : ' = '
+            return oldText.slice(0, oldText.indexOf(startMarker) + startMarker.length) + newTypeName + oldText.slice(oldText.indexOf(endMarker))
+        }
+
+        const fileEdit = prior.edits[0]!
+        const { textChanges } = fileEdit
+
+        const sourceFile = languageService.getProgram()!.getSourceFile(fileName)!
+        let node = findChildContainingExactPosition(sourceFile, textChanges[1]!.span.start - 1)
+        if (!node) return
+        if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node)) node = node.parent
+        if (ts.isVariableDeclaration(node) || ts.isParameter(node) || ts.isPropertyAssignment(node) || ts.isPropertySignature(node)) {
+            let isWithinType = ts.isPropertySignature(node)
+            if (ts.isIdentifier(node.name)) {
+                const identifierName = node.name.text
+                if (!identifierName) return
+                let typeName = identifierName[0]!.toUpperCase() + identifierName.slice(1)
+                if (!isWithinType) typeName += 'Type'
+                const newFileEdit: ts.FileTextChanges = {
+                    fileName,
+                    textChanges: textChanges.map((textChange, i) => {
+                        if (i === 0) return { ...textChange, newText: changeFirstEdit(textChange.newText, typeName) }
+                        /* if (i === 1) */ return { ...textChange, newText: typeName }
+                    }),
+                }
+                return {
+                    edits: [newFileEdit],
+                }
+            }
+        }
+        return prior
+    }
+    return
+}