feat: Big features! Hide or change sorting of auto-imports. Configurable per specific module and symbol name!

Author: zardoy

README.MD

@@ -179,6 +179,38 @@ const a = 5
 a = 6
 ```
 
+## Auto Imports
+
+With this plugin you have total (almost) control over auto imports that appear in completions, quick fixes and import all quick fix. Some examples of what you can do:
+
+- I never want to see `join` suggestion from `path/win32` module (it's a Node.js [module](https://nodejs.org/dist/latest-v18.x/docs/api/path.html#pathwin32), defined via module augmentation)
+- I never want to see any suggestions from `path/*` modules
+- I always want `join` to be imported from `path/posix` module on window (also would appear first in completions & single quick fix)
+- I always want `useState` to be imported from local files first
+
+Some settings examples:
+
+<!-- just duplicated from configurationType -->
+
+```jsonc
+"suggestions.ignoreAutoImport": [
+  "path", // ignore path, but not path/posix or path/win32 modules
+  "path/*", // ignore path, path/posix and path/win32
+  "path/*#join", // ignore path, path/posix and path/win32, but only join symbol
+  "path/*#join,resolve", // ignore path, path/posix and path/win32, but only join and resolve symbol
+],
+"autoImport.changeSorting": {
+    "join": ["path/posix"], // other suggestions will be below
+    "resolve": ["*", "path/posix"], // make `path/posix` appear below any other suggestions
+    "useState": ["."], // `.` (dot) is reserved for local suggestions, which makes them appear above other
+},
+// for some even more specific cases?
+// "autoImport.alwaysIgnoreInImportAll": ["lodash"] // exclude all possible imports from import all request
+```
+
+> 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
+
 ## Special Commands List
 
 ### Go to / Select Nodes by Kind

src/configurationType.ts

@@ -56,13 +56,31 @@ export type Configuration = {
      */
     'patchToString.enable': boolean
     /**
+     * Format of this setting is very close to `jsxCompletionsMap` setting:
+     * `path#symbol` (exact) or `path/*#symbol` (`#symbol` part can be ommited)
+     *
      * Note: Please use `javascript`/`typescript.preferences.autoImportFileExcludePatterns` when possible, to achieve better performance!
+     *
      * e.g. instead of declaring `@mui/icons-material` here, declare `node_modules/@mui/icons-material` in aforementioned setting.
      *
      * And only use this, if auto-imports coming not from physical files (e.g. some modules node imports)
+     *
+     * Examples:
+     * - `path` - ignore path, but not path/posix or path/win32 modules
+     * - `path/*` - ignore path, path/posix and path/win32
+     * - `path/*#join` - ignore path, path/posix and path/win32, but only join symbol
+     * - `path/*#join,resolve` - ignore path, path/posix and path/win32, but only join and resolve symbol
+     *
+     * - jquery/* - ignore absolutely all auto imports from jquery, even if it was declared virtually (declare module)
      * @default []
      */
-    'suggestions.banAutoImportPackages': string[]
+    'suggestions.ignoreAutoImport': string[]
+    /**
+     * Disable it only if it causes problems / crashes with TypeScript, which of course should never happen
+     * But it wasn't tested on very old versions
+     * @default false
+     */
+    // 'advanced.disableAutoImportCodeFixPatching': boolean
     /**
      * What insert text to use for keywords (e.g. `return`)
      * @default space
@@ -366,15 +384,22 @@ export type Configuration = {
      */
     'experiments.excludeNonJsxCompletions': boolean
     /**
-     * Format of this setting is very close to `jsxCompletionsMap` setting:
-     * path#symbol
-     * Examples (keys in object):
-     * #join - adjust `join` symbol from every module
-     * path/win32#join - adjust `join` symbol from from path/win32 module
-     * path/
-     * Adjust actions (values in object):
-     * false - completely disable symbol(s) suggesting
-     * array of strings - change sorting of - first takes precedence for auto-imports (code actions & suggestions)
-     */
-    'autoImport.adjustBySymbol': { ['path#symbol'] }
+     * Map *symbol - array of modules* to change sorting of imports - first available takes precedence in auto import code fixes (+ import all action)
+     *
+     * Examples:
+     * - `join`: ['path/posix'] // other suggestions will be below
+     * - `resolve`: ['*', 'path/posix'] // make `path/posix` appear below any other suggestions
+     * - `useEventListener`: ['.'] // `.` (dot) is reserved for local suggestions, which makes them appear above other
+     * @default {}
+     */
+    'autoImport.changeSorting': { [pathAndOrSymbol: string]: string[] }
+    /**
+     * Advanced. Use `suggestions.ignoreAutoImport` setting if possible.
+     *
+     * Packages to ignore in import all fix.
+     *
+     * TODO syntaxes /* and module#symbol unsupported (easy)
+     * @default []
+     */
+    'autoImport.alwaysIgnoreInImportAll': string[]
 }

src/migrateSettings.ts

@@ -17,6 +17,13 @@ export default () => {
                     mustBePrimitive: true,
                 },
             },
+            {
+                rename: {
+                    old: 'suggestions.banAutoImportPackages',
+                    new: 'suggestions.ignoreAutoImport',
+                    mustBePrimitive: false,
+                },
+            },
         ],
         process.env.IDS_PREFIX!,
     )

typescript/src/adjustAutoImports.ts

@@ -0,0 +1,99 @@
+import { GetConfig } from './types'
+import { addObjectMethodResultInterceptors, findChildContainingExactPosition } from './utils'
+
+let currentSymbolName: string | undefined
+
+interface ParsedIgnoreSetting {
+    module: string
+    symbols: string[]
+    isAnySymbol: boolean
+    moduleCompare: 'startsWith' | 'strict'
+}
+
+// will be removed once I'm sure performance can't be improved
+const initIgnoreAutoImport = () => {
+    addObjectMethodResultInterceptors(tsFull, {
+        // todo
+        createPackageJsonImportFilter(res, fromFile) {
+            return {
+                ...res,
+                allowsImportingAmbientModule(moduleSymbol, moduleSpecifierResolutionHost) {
+                    return true
+                    // return isModuleShouldBeIgnored(moduleSymbol.name.slice(1, -1), '')
+                },
+                // allowsImportingSourceFile(sourceFile, moduleSpecifierResolutionHost) {
+                //     return false
+                // },
+                allowsImportingSpecifier(moduleSpecifier) {
+                    const result = res.allowsImportingSpecifier(moduleSpecifier)
+                    if (!result) return false
+                    return false
+                },
+            }
+        },
+    })
+    // addObjectMethodResultInterceptors(tsFull.codefix, {
+    //     getAllFixes(res) {
+    //         return res
+    //     },
+    // })
+}
+
+export const getIgnoreAutoImportSetting = (c: GetConfig) => {
+    return c('suggestions.ignoreAutoImport').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 === '*'
+        return {
+            module,
+            symbols: isAnySymbol ? [] : symbolsString.split(','),
+            isAnySymbol,
+            moduleCompare,
+        }
+    })
+}
+
+export const isAutoImportEntryShouldBeIgnored = (ignoreAutoImportSetting: ParsedIgnoreSetting[], targetModule: string, symbol: string) => {
+    for (const { module, moduleCompare, isAnySymbol, symbols } of ignoreAutoImportSetting) {
+        const isIgnoreModule = moduleCompare === 'startsWith' ? targetModule.startsWith(module) : targetModule === module
+        if (!isIgnoreModule) continue
+        if (isAnySymbol) return true
+        if (!symbols.includes(symbol)) continue
+        return true
+    }
+    return false
+}
+
+export const shouldChangeSortingOfAutoImport = (symbolName: string, c: GetConfig) => {
+    const arr = c('autoImport.changeSorting')[symbolName]
+    return arr && arr.length > 0
+}
+
+export const changeSortingOfAutoImport = (c: GetConfig, symbolName: string): ((module: string) => number) => {
+    const arr = c('autoImport.changeSorting')[symbolName]
+    if (!arr || !arr.length) return () => 0
+    const maxIndex = arr.length
+    return module => {
+        let actualIndex = arr.findIndex(x => {
+            return x.endsWith('/*') ? module.startsWith(x.slice(0, -'/*'.length)) : module === x
+        })
+        // . - index, don't treat some node_modules-ignored modules as local such as `.vite`
+        const isLocal = module.startsWith('./') || module.startsWith('../') || module === '.'
+        if (actualIndex === -1) actualIndex = arr.findIndex(x => (isLocal ? x === '.' : x === '*'))
+        return actualIndex === -1 ? maxIndex : actualIndex
+    }
+}