feat: Namespace Imports! Add a new setting that allows you to make *auto imports* add namespace imports instead of named imports (also with ability to use global variables instead)

Author: zardoy

README.MD

@@ -102,9 +102,9 @@ This also makes plugin work in Volar's takeover mode!
 
 ### Web Support
 
-> Note: when you open TS/JS file in the web for the first time you currently need to switch editors to make everything work!
+> Note: when you open TS/JS file in the web for the first time you currently need to switch between editors to make plugin work.
 
-Web-only feature: `import` path resolution
+There is web-only feature: fix clicking on relative `import` paths.
 
 ### `in` Keyword Suggestions
 
@@ -149,9 +149,9 @@ Appends *space* to almost all keywords e.g. `const `, like WebStorm does.
 
 (*enabled by default*)
 
-Patches `toString()` insert function snippet on number types to remove tabStop.
+Patches `toString()` insert function snippet on number types to remove annoying tab stop.
 
-### Enforce Properties Sorting
+### Restore Properties Sorting
 
 (*disabled by default*) enable with `tsEssentialPlugins.fixSuggestionsSorting`
 
@@ -162,11 +162,7 @@ Try to restore [original](https://github.com/microsoft/TypeScript/issues/49012)
 We extend completion list with extensions from module augmentation (e.g. `.css` files if you have `declare module '*.css'`).
 But for unchecked contexts list of extensions can be extended with `tsEssentialPlugins.additionalIncludeExtensions` setting.
 
-### Switch Exclude Covered Cases
-
-(*enabled by default*)
-
-Exclude already covered strings / enums from suggestions ([TS repo issue](https://github.com/microsoft/TypeScript/issues/13711)).
+<!-- ## Type-Driven Completions -->
 
 ### Mark Code Actions
 
@@ -226,7 +222,58 @@ Some settings examples:
 ```
 
 > Note: changeSorting might not preserve sorting of other existing suggestions which not defined by rules, there is WIP
-> Also I'm thinking of making it learn and syncing of most-used imports automatically
+> Also I'm thinking of making it learn and sync most-used imports automatically
+
+### Namespace Imports
+
+If you always want some modules to be imported automatically as namespace import, you're lucky as there is `autoImport.changeToNamespaceImport` setting for this.
+
+Example:
+
+You're completing following Node.js code in empty file:
+
+```ts
+readFileSync
+```
+
+Default completion and code fix will change it to:
+
+```ts
+import { readFileSync } from 'fs'
+
+readFileSync
+```
+
+But if you setup this setting:
+
+```json
+"tsEssentialPlugins.autoImport.changeToNamespaceImport": {
+    "fs": {},
+},
+```
+
+Completing the same code or accepting import code fix will result:
+
+```ts
+import * as fs from 'fs'
+
+fs.readFileSync
+```
+
+There is also a way to specify different name for namespace or use default import instead.
+
+However there are cases where you have some modules injected globally in your application (e.g. global `React` variable), then you can specify *auto imports feature* to use them instead of adding an import:
+
+```json
+"tsEssentialPlugins.autoImport.changeToNamespaceImport": {
+    "react": {
+        "namespace": "React",
+        "addImport": false
+    },
+},
+```
+
+`useState` -> `React.useState`
 
 ## Rename Features
 

src/configurationType.ts

@@ -443,19 +443,21 @@ export type Configuration = {
     /**
      * Advanced. Use `suggestions.ignoreAutoImports` setting if possible.
      *
-     * Packages to ignore in import all fix.
+     * Specify packages to ignore in *add all missing imports* fix, to ensure these packages never get imported automatically.
      *
      * TODO syntaxes /* and module#symbol unsupported (easy)
      * @default []
      */
     'autoImport.alwaysIgnoreInImportAll': string[]
     /**
+     * Specify here modules should be imported as namespace import. But note that imports gets processed first by `suggestions.ignoreAutoImports` anyway.
+     *
      * @default {}
      */
     'autoImport.changeToNamespaceImport': {
         [module: string]: {
             /**
-             * @default module (key)
+             * Defaults to key
              */
             namespace?: string
             /**
@@ -464,6 +466,7 @@ export type Configuration = {
             useDefaultImport?: boolean
             /**
              * Set to `false` if module is acessible from global variable
+             * For now not supported in add all missing imports code action
              * @default true */
             addImport?: boolean
         }

typescript/src/adjustAutoImports.ts

@@ -39,32 +39,34 @@ const initIgnoreAutoImport = () => {
     // })
 }
 
-export const getIgnoreAutoImportSetting = (c: GetConfig) => {
-    return c('suggestions.ignoreAutoImports').map((spec): ParsedIgnoreSetting => {
-        const hashIndex = spec.indexOf('#')
-        let module = hashIndex === -1 ? spec : spec.slice(0, hashIndex)
-        const moduleCompare = module.endsWith('/*') ? 'startsWith' : 'strict'
-        if (moduleCompare === 'startsWith') {
-            module = module.slice(0, -'/*'.length)
-        }
-        if (hashIndex === -1) {
-            return {
-                module,
-                symbols: [],
-                isAnySymbol: true,
-                moduleCompare,
-            }
-        }
-        const symbolsString = spec.slice(hashIndex + 1)
-        // * (glob asterisk) is reserved for future ussage
-        const isAnySymbol = symbolsString === '*'
+export function parseIgnoreSpec(spec: string): ParsedIgnoreSetting {
+    const hashIndex = spec.indexOf('#')
+    let module = hashIndex === -1 ? spec : spec.slice(0, hashIndex)
+    const moduleCompare = module.endsWith('/*') ? 'startsWith' : 'strict'
+    if (moduleCompare === 'startsWith') {
+        module = module.slice(0, -'/*'.length)
+    }
+    if (hashIndex === -1) {
         return {
             module,
-            symbols: isAnySymbol ? [] : symbolsString.split(','),
-            isAnySymbol,
+            symbols: [],
+            isAnySymbol: true,
             moduleCompare,
         }
-    })
+    }
+    const symbolsString = spec.slice(hashIndex + 1)
+    // * (glob asterisk) is reserved for future ussage
+    const isAnySymbol = symbolsString === '*'
+    return {
+        module,
+        symbols: isAnySymbol ? [] : symbolsString.split(','),
+        isAnySymbol,
+        moduleCompare,
+    }
+}
+
+export const getIgnoreAutoImportSetting = (c: GetConfig) => {
+    return c('suggestions.ignoreAutoImports').map(spec => parseIgnoreSpec(spec))
 }
 
 export const isAutoImportEntryShouldBeIgnored = (ignoreAutoImportsSetting: ParsedIgnoreSetting[], targetModule: string, symbol: string) => {
@@ -78,6 +80,17 @@ export const isAutoImportEntryShouldBeIgnored = (ignoreAutoImportsSetting: Parse
     return false
 }
 
+export const findIndexOfAutoImportSpec = (ignoreAutoImportsSetting: ParsedIgnoreSetting[], targetModule: string, symbol: string) => {
+    for (const [i, { module, moduleCompare, isAnySymbol, symbols }] of ignoreAutoImportsSetting.entries()) {
+        const isIgnoreModule = moduleCompare === 'startsWith' ? targetModule.startsWith(module) : targetModule === module
+        if (!isIgnoreModule) continue
+        if (isAnySymbol) return i
+        if (!symbols.includes(symbol)) continue
+        return i
+    }
+    return
+}
+
 export const shouldChangeSortingOfAutoImport = (symbolName: string, c: GetConfig) => {
     const arr = c('autoImport.changeSorting')[symbolName]
     return arr && arr.length > 0

typescript/src/codeFixes.ts

@@ -2,7 +2,8 @@ import _ from 'lodash'
 import addMissingProperties from './codeFixes/addMissingProperties'
 import { changeSortingOfAutoImport, getIgnoreAutoImportSetting, isAutoImportEntryShouldBeIgnored } from './adjustAutoImports'
 import { GetConfig } from './types'
-import { findChildContainingPosition, getIndentFromPos, patchMethod } from './utils'
+import { findChildContainingPosition, getCancellationToken, getIndentFromPos, patchMethod } from './utils'
+import namespaceAutoImports from './namespaceAutoImports'
 
 // codeFixes that I managed to put in files
 const externalCodeFixes = [addMissingProperties]
@@ -22,33 +23,61 @@ export default (proxy: ts.LanguageService, languageService: ts.LanguageService,
             [Diagnostics.Remove_type_from_import_of_0_from_1, 1, 0],
             [Diagnostics.Remove_type_from_import_declaration_from_0, 0],
         ]
-        const oldCreateCodeFixAction = tsFull.codefix.createCodeFixAction
+        const addNamespaceImports = [] as ts.CodeFixAction[]
+
         let prior: readonly ts.CodeFixAction[]
+        let toUnpatch: (() => void)[] = []
         try {
             const { importFixName } = tsFull.codefix
             const ignoreAutoImportsSetting = getIgnoreAutoImportSetting(c)
             const sortFn = changeSortingOfAutoImport(c, (node as ts.Identifier).text)
-            tsFull.codefix.createCodeFixAction = (fixName, changes, description, fixId, fixAllDescription, command) => {
-                if (fixName !== importFixName) return oldCreateCodeFixAction(fixName, changes, description, fixId, fixAllDescription, command)
-                const placeholderIndexesInfo = moduleSymbolDescriptionPlaceholders.find(([diag]) => diag === description[0])
-                let sorting = '-1'
-                if (placeholderIndexesInfo) {
-                    const targetModule = description[placeholderIndexesInfo[1] + 1]
-                    const symbolName = placeholderIndexesInfo[2] !== undefined ? description[placeholderIndexesInfo[2] + 1] : (node as ts.Identifier).text
-                    const toIgnore = isAutoImportEntryShouldBeIgnored(ignoreAutoImportsSetting, targetModule, symbolName)
-                    if (toIgnore) {
-                        return {
-                            fixName: 'IGNORE',
-                            changes: [],
-                            description: '',
+            const unpatch = patchMethod(
+                tsFull.codefix,
+                'createCodeFixAction',
+                oldCreateCodeFixAction => (fixName, changes, description, fixId, fixAllDescription, command) => {
+                    if (fixName !== importFixName) return oldCreateCodeFixAction(fixName, changes, description, fixId, fixAllDescription, command)
+                    const placeholderIndexesInfo = moduleSymbolDescriptionPlaceholders.find(([diag]) => diag === description[0])
+                    let sorting = '-1'
+                    if (placeholderIndexesInfo) {
+                        const targetModule = description[placeholderIndexesInfo[1] + 1]
+                        const symbolName = placeholderIndexesInfo[2] !== undefined ? description[placeholderIndexesInfo[2] + 1] : (node as ts.Identifier).text
+
+                        const toIgnore = isAutoImportEntryShouldBeIgnored(ignoreAutoImportsSetting, targetModule, symbolName)
+
+                        const namespaceImportAction =
+                            !toIgnore && namespaceAutoImports(c, sourceFile, targetModule, preferences, formatOptions, start, symbolName)
+
+                        if (namespaceImportAction) {
+                            const { textChanges, description } = namespaceImportAction
+                            addNamespaceImports.push({
+                                fixName: importFixName,
+                                fixAllDescription: 'Add all missing imports',
+                                fixId: 'fixMissingImport',
+                                description,
+                                changes: [
+                                    {
+                                        fileName,
+                                        textChanges,
+                                    },
+                                ],
+                            })
+                        }
+                        if (toIgnore /*  || namespaceImportAction */) {
+                            return {
+                                fixName: 'IGNORE',
+                                changes: [],
+                                description: '',
+                            }
                         }
+                        sorting = sortFn(targetModule).toString()
+                        // todo this workaround is weird, sort in another way
                     }
-                    sorting = sortFn(targetModule).toString()
-                    // todo this workaround is weird, sort in another way
-                }
-                return oldCreateCodeFixAction(fixName + sorting, changes, description, fixId, fixAllDescription, command)
-            }
+                    return oldCreateCodeFixAction(fixName + sorting, changes, description, fixId, fixAllDescription, command)
+                },
+            )
+            toUnpatch.push(unpatch)
             prior = languageService.getCodeFixesAtPosition(fileName, start, end, errorCodes, formatOptions, preferences)
+            prior = [...addNamespaceImports, ...prior]
             prior = _.sortBy(prior, ({ fixName }) => {
                 if (fixName.startsWith(importFixName)) {
                     return +fixName.slice(importFixName.length)
@@ -63,7 +92,7 @@ export default (proxy: ts.LanguageService, languageService: ts.LanguageService,
                 throw err
             })
         } finally {
-            tsFull.codefix.createCodeFixAction = oldCreateCodeFixAction
+            toUnpatch.forEach(x => x())
         }
         // todo remove when 5.0 is released after 3 months
         // #region fix builtin codefixes/refactorings
@@ -150,12 +179,8 @@ export default (proxy: ts.LanguageService, languageService: ts.LanguageService,
                 languageServiceHost as any /* cancellationToken */,
             )
             const semanticDiagnostics = languageService.getSemanticDiagnostics(fileName)
-            const cancellationToken = languageServiceHost.getCompilerHost?.()?.getCancellationToken?.() ?? {
-                isCancellationRequested: () => false,
-                throwIfCancellationRequested: () => {},
-            }
             const context: Record<keyof import('typescript-full').CodeFixContextBase, any> = {
-                cancellationToken,
+                cancellationToken: getCancellationToken(languageServiceHost),
                 formatContext: tsFull.formatting.getFormatContext(formatOptions, languageServiceHost),
                 host: languageServiceHost,
                 preferences,
@@ -164,6 +189,7 @@ export default (proxy: ts.LanguageService, languageService: ts.LanguageService,
             }
             const errorCodes = getFixAllErrorCodes()
             const ignoreAutoImportsSetting = getIgnoreAutoImportSetting(c)
+            const additionalTextChanges: ts.TextChange[] = []
             for (const diagnostic of semanticDiagnostics) {
                 if (!errorCodes.includes(diagnostic.code)) continue
                 const toUnpatch: (() => any)[] = []
@@ -185,6 +211,38 @@ export default (proxy: ts.LanguageService, languageService: ts.LanguageService,
                                         }),
                                         ({ fix }) => sortFn(fix.moduleSpecifier),
                                     )
+                                    const firstFix = fixes[0]
+                                    const namespaceImportAction =
+                                        !!firstFix &&
+                                        namespaceAutoImports(
+                                            c,
+                                            sourceFile,
+                                            firstFix.fix.moduleSpecifier,
+                                            preferences,
+                                            formatOptions,
+                                            diagnostic.start!,
+                                            firstFix.symbolName,
+                                        )
+                                    if (namespaceImportAction) {
+                                        fixes = []
+                                        if (!namespaceImportAction.namespace) {
+                                            additionalTextChanges.push(...namespaceImportAction.textChanges)
+                                        } else {
+                                            const { namespace, useDefaultImport, textChanges } = namespaceImportAction
+                                            additionalTextChanges.push(textChanges[1]!)
+                                            fixes.unshift({
+                                                ...fixes[0]!,
+                                                fix: {
+                                                    kind: ImportFixKind.AddNew,
+                                                    moduleSpecifier: firstFix.fix.moduleSpecifier,
+                                                    importKind: useDefaultImport ? tsFull.ImportKind.Default : tsFull.ImportKind.Namespace,
+                                                    addAsTypeOnly: false,
+                                                    useRequire: false,
+                                                },
+                                                symbolName: namespace,
+                                            } as FixInfo)
+                                        }
+                                    }
                                     if (!fixes[0]) throw new Error('No fixes')
                                     return fixes[0]
                                 }) as any,
@@ -209,7 +267,10 @@ export default (proxy: ts.LanguageService, languageService: ts.LanguageService,
                     }
                 }
             }
-            return tsFull.codefix.createCombinedCodeActions(tsFull.textChanges.ChangeTracker.with(context, importAdder.writeFixes))
+            return tsFull.codefix.createCombinedCodeActions([
+                ...tsFull.textChanges.ChangeTracker.with(context, importAdder.writeFixes),
+                { fileName, textChanges: additionalTextChanges },
+            ])
         }
         return languageService.getCombinedCodeFix(scope, fixId, formatOptions, preferences)
     }