arch: add code action architecture & example which is disable at the moment

Author: zardoy

typescript/src/codeActions/getCodeActions.ts

@@ -0,0 +1,79 @@
+import { compact } from '@zardoy/utils'
+import type tslib from 'typescript/lib/tsserverlibrary'
+import toggleBraces from './toggleBraces'
+
+type SimplifiedRefactorInfo = {
+    start: number
+    length: number
+    newText: string
+}
+
+export type ApplyCodeAction = (
+    ts: typeof tslib,
+    sourceFile: tslib.SourceFile,
+    position: number,
+    range?: tslib.TextRange,
+) => tslib.RefactorEditInfo | SimplifiedRefactorInfo[] | undefined
+
+export type CodeAction = {
+    name: string
+    id: string
+    tryToApply: ApplyCodeAction
+}
+
+const codeActions: CodeAction[] = [
+    /* toggleBraces */
+]
+
+export const REFACTORS_CATEGORY = 'essential-refactors'
+
+export default (
+    ts: typeof tslib,
+    sourceFile: tslib.SourceFile,
+    positionOrRange: tslib.TextRange | number,
+    requestingEditsId?: string,
+): { info?: ts.ApplicableRefactorInfo; edit: tslib.RefactorEditInfo } => {
+    const range = typeof positionOrRange !== 'number' && positionOrRange.pos !== positionOrRange.end ? positionOrRange : undefined
+    const appliableCodeActions = compact(
+        codeActions.map(action => {
+            const edits = action.tryToApply(ts, sourceFile, typeof positionOrRange === 'number' ? positionOrRange : positionOrRange.pos, range)
+            if (!edits) return
+            return {
+                ...action,
+                edits: Array.isArray(edits)
+                    ? ({
+                          edits: [
+                              {
+                                  fileName: sourceFile.fileName,
+                                  textChanges: edits.map(({ length, newText, start }) => {
+                                      return {
+                                          newText,
+                                          span: {
+                                              length,
+                                              start,
+                                          },
+                                      }
+                                  }),
+                              },
+                          ],
+                      } as tslib.RefactorEditInfo)
+                    : edits,
+            }
+        }),
+    )
+
+    return {
+        info:
+            (appliableCodeActions.length && {
+                actions: appliableCodeActions.map(({ id, name }) => ({
+                    description: name,
+                    name: id,
+                })),
+                // anyway not visible in ui
+                description: 'Essential Refactors',
+                name: REFACTORS_CATEGORY,
+            }) ||
+            undefined,
+        edit: requestingEditsId ? appliableCodeActions.find(({ id }) => id === requestingEditsId)!.edits : null!,
+    }
+}

typescript/src/codeActions/toggleBraces.ts

@@ -0,0 +1,42 @@
+import { Statement } from 'typescript/lib/tsserverlibrary'
+import { findChildContainingPosition, findClosestParent, getIndentFromPos } from '../utils'
+import { ApplyCodeAction, CodeAction } from './getCodeActions'
+
+const tryToApply: ApplyCodeAction = (ts, sourceFile, pos, range) => {
+    const currentNode = findChildContainingPosition(ts, sourceFile, pos)
+    if (!currentNode) return
+    const closestBlock = findClosestParent(
+        ts,
+        currentNode,
+        [
+            ts.SyntaxKind.IfStatement,
+            ts.SyntaxKind.ForStatement,
+            ts.SyntaxKind.ForOfStatement,
+            ts.SyntaxKind.ForInStatement,
+            ts.SyntaxKind.WhileStatement,
+            // ts.SyntaxKind.Block
+        ],
+        [],
+    )
+    if (!closestBlock) return
+    let wrapNode: Statement | undefined
+    if (ts.isForStatement(closestBlock) || ts.isForOfStatement(closestBlock) || ts.isForInStatement(closestBlock) || ts.isWhileStatement(closestBlock)) {
+        wrapNode = closestBlock.statement
+    } else if (ts.isIfStatement(closestBlock)) {
+        wrapNode = closestBlock.thenStatement
+    }
+    if (wrapNode && !ts.isBlock(wrapNode)) {
+        const startIndent = getIndentFromPos(ts, sourceFile, pos)
+        return [
+            { start: wrapNode.getStart(), length: 0, newText: `{\n${startIndent}\t` },
+            { start: wrapNode.getEnd(), length: 0, newText: `\n${startIndent}}` },
+        ]
+    }
+    return
+}
+
+export default {
+    name: 'Toggle Braces',
+    id: 'toggleBraces',
+    tryToApply,
+} as CodeAction

typescript/src/index.ts

@@ -13,6 +13,7 @@ import { findChildContainingPosition, getIndentFromPos } from './utils'
 import { getParameterListParts } from './snippetForFunctionCall'
 import { getNavTreeItems } from './getPatchedNavTree'
 import { join } from 'path'
+import getCodeActions, { REFACTORS_CATEGORY } from './codeActions/getCodeActions'
 
 const thisPluginMarker = Symbol('__essentialPluginsMarker__')
 
@@ -154,9 +155,25 @@ export = function ({ typescript }: { typescript: typeof import('typescript/lib/t
 
                 if (c('markTsCodeActions.enable')) prior = prior.map(item => ({ ...item, description: `🔵 ${item.description}` }))
 
+                const program = info.languageService.getProgram()
+                const sourceFile = program!.getSourceFile(fileName)!
+                const { info: refactorInfo } = getCodeActions(ts, sourceFile, positionOrRange)
+                if (refactorInfo) prior = [...prior, refactorInfo]
+
                 return prior
             }
 
+            proxy.getEditsForRefactor = (fileName, formatOptions, positionOrRange, refactorName, actionName, preferences) => {
+                const category = refactorName
+                if (category === REFACTORS_CATEGORY) {
+                    const program = info.languageService.getProgram()
+                    const sourceFile = program!.getSourceFile(fileName)!
+                    const { edit } = getCodeActions(ts, sourceFile, positionOrRange, actionName)
+                    return edit
+                }
+                return info.languageService.getEditsForRefactor(fileName, formatOptions, positionOrRange, refactorName, actionName, preferences)
+            }
+
             proxy.getCodeFixesAtPosition = (fileName, start, end, errorCodes, formatOptions, preferences) => {
                 let prior = info.languageService.getCodeFixesAtPosition(fileName, start, end, errorCodes, formatOptions, preferences)
                 // fix builtin codefixes/refactorings