feat: new powerful declare missing property snippet codefix that by default works only in the same file, but can be extended with a new setting. Was designed specificially for styles.create pattern!

Author: zardoy

.vscode/settings.json

@@ -3,6 +3,10 @@
         "typescript/lib/tsserverlibrary": {
             "namespace": "ts",
             "addImport": false
+        },
+        "typescript": {
+            "namespace": "ts",
+            "addImport": false
         }
     },
     "typescript.preferences.autoImportFileExcludePatterns": [
@@ -24,5 +28,5 @@
     "vitest.showFailMessages": true,
     "vitest.include": [
         "typescript/test/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"
-    ]
+    ],
 }

src/configurationType.ts

@@ -680,6 +680,10 @@ export type Configuration = {
     // bigFilesThreshold: number
     /** @default false */
     enableHooksFile: boolean
+    /**
+     * @default false
+     */
+    declareMissingPropertyQuickfixOtherFiles: boolean
 }
 
 // scrapped using search editor. config: caseInsensitive, context lines: 0, regex: const fix\w+ = "[^ ]+"

typescript/src/codeActions/extended/declareMissingProperties.ts

@@ -5,8 +5,52 @@ export default {
     codes: [2339],
     kind: 'quickfix',
     title: 'Declare missing property',
-    tryToApply({ sourceFile, node }) {
+    tryToApply({ sourceFile, node, c, languageService }) {
         const param = matchParents(node, ['Identifier', 'BindingElement', 'ObjectBindingPattern', 'Parameter'])
+        const objAccess = matchParents(node, ['Identifier', 'PropertyAccessExpression'])
+        const missingPropName = (node as ts.Identifier).text
+        if (objAccess) {
+            const checker = languageService.getProgram()!.getTypeChecker()!
+            const type = checker.getContextualType(objAccess.expression) || checker.getTypeAtLocation(objAccess.expression)
+            const props = type
+                .getProperties()
+                .map(type => {
+                    const node = type.declarations?.find(declaration => {
+                        return c('declareMissingPropertyQuickfixOtherFiles') || declaration.getSourceFile().fileName === sourceFile.fileName
+                    })
+                    if (node === undefined) return undefined!
+                    return { name: type.name, node }
+                })
+                .filter(Boolean)
+            // TARGET PROP
+            const propInsertAfter = props.find(prop => missingPropName.startsWith(prop.name)) ?? props.at(-1)
+            if (propInsertAfter) {
+                const propInsertParent = propInsertAfter.node.parent
+                const sameParentLiteralProps = props.filter(
+                    prop => prop.node.parent === propInsertParent && ts.isPropertyAssignment(prop.node) && !ts.isIdentifier(prop.node.initializer),
+                )
+                const insertObject =
+                    sameParentLiteralProps.length > 0 &&
+                    sameParentLiteralProps.every(sameParentProp => ts.isObjectLiteralExpression((sameParentProp.node as ts.PropertyAssignment).initializer))
+                const insertPos = propInsertAfter.node.end
+                const insertComma = sourceFile.getFullText().slice(insertPos - 1, insertPos) !== ','
+                const getLine = pos => sourceFile.getLineAndCharacterOfPosition(pos).line
+                const insertNewLine = getLine(propInsertAfter.node.pos) !== getLine(propInsertAfter.node.end)
+                const insertText = `${insertComma ? ',' : ''}${insertNewLine ? '\n' : ' '}${missingPropName}`
+                const snippet = insertObject ? `: {${insertNewLine ? '\n\t' : ''}$0${insertNewLine ? '\n' : ''}}` : `$0`
+                return {
+                    snippetEdits: [
+                        {
+                            newText: `${tsFull.escapeSnippetText(insertText)}${snippet}`,
+                            span: {
+                                length: 0,
+                                start: insertPos,
+                            },
+                        },
+                    ],
+                }
+            }
+        }
         if (param) {
             // special react pattern
             if (ts.isArrowFunction(param.parent) && ts.isVariableDeclaration(param.parent.parent)) {
@@ -20,7 +64,7 @@ export default {
                 const hasMembers = param.type.members.length > 0
                 const insertPos = param.type.members.at(-1)?.end ?? param.type.end - 1
                 const insertComma = hasMembers && sourceFile.getFullText().slice(insertPos - 1, insertPos) !== ','
-                let insertText = (node as ts.Identifier).text
+                let insertText = missingPropName
                 if (insertComma) insertText = `, ${insertText}`
                 // alternatively only one snippetEdit could be used with tsFull.escapeSnippetText(insertText) + $0
                 return {

typescript/src/codeActions/getCodeActions.ts

@@ -2,6 +2,7 @@ import { compact } from '@zardoy/utils'
 import { Except } from 'type-fest'
 import { findChildContainingExactPosition, findChildContainingPosition } from '../utils'
 import { ApplyExtendedCodeActionResult, IpcExtendedCodeAction } from '../ipcTypes'
+import { GetConfig } from '../types'
 import objectSwapKeysAndValues from './custom/objectSwapKeysAndValues'
 import changeStringReplaceToRegex from './custom/changeStringReplaceToRegex'
 import splitDeclarationAndInitialization from './custom/splitDeclarationAndInitialization'
@@ -56,6 +57,7 @@ export type ApplyExtendedCodeAction = (options: {
     /** undefined when no edits is requested */
     formatOptions: ts.FormatCodeSettings | undefined
     languageService: ts.LanguageService
+    c: GetConfig
     // languageServiceHost: ts.LanguageServiceHost
 }) => ApplyExtendedCodeActionResult | boolean | undefined
 
@@ -80,6 +82,7 @@ export const getExtendedCodeActions = <T extends string | undefined>(
     // languageServiceHost: ts.LanguageServiceHost,
     formatOptions: ts.FormatCodeSettings | undefined,
     applyCodeActionTitle: T,
+    config: GetConfig,
     filterErrorCodes?: number[],
 ): T extends undefined ? ExtendedCodeAction[] : ApplyExtendedCodeActionResult => {
     const range = typeof positionOrRange !== 'number' && positionOrRange.pos !== positionOrRange.end ? positionOrRange : undefined
@@ -93,6 +96,7 @@ export const getExtendedCodeActions = <T extends string | undefined>(
         position,
         range,
         sourceFile,
+        c: config,
     }
     if (applyCodeActionTitle) {
         const codeAction = extendedCodeActions.find(codeAction => codeAction.title === applyCodeActionTitle)

typescript/src/specialCommands/handle.ts

@@ -40,7 +40,15 @@ export default (
         const node = findChildContainingPosition(ts, sourceFile, position)
         const posEnd = { pos: specialCommandArg.range[0], end: specialCommandArg.range[1] }
 
-        const extendedCodeActions = getExtendedCodeActions(sourceFile, posEnd, languageService, undefined, undefined, specialCommandArg.diagnostics)
+        const extendedCodeActions = getExtendedCodeActions(
+            sourceFile,
+            posEnd,
+            languageService,
+            undefined,
+            undefined,
+            configuration,
+            specialCommandArg.diagnostics,
+        )
         return {
             turnArrayIntoObject: objectIntoArrayConverters(posEnd, node, undefined),
             extendedCodeActions,
@@ -56,6 +64,7 @@ export default (
             languageService,
             formatOptions,
             applyCodeActionTitle,
+            configuration,
         ) satisfies RequestOutputTypes['getExtendedCodeActionEdits']
     }
     if (specialCommand === 'twoStepCodeActionSecondStep') {