feat: caseSensitiveCompletions (disabled by default)!

feat: `disableFuzzyCompletions` (disabled by default) - filter completions that start with entered text

Author: zardoy

README.MD

@@ -64,6 +64,12 @@ const usersList = []
 usersList.map // -> usersList.map((user) => )
 ```
 
+### Case-sensitive Completions
+
+(*disabled by default*)
+
+Filter out completions that start with different casing.
+
 ### Remove Definition From References
 
 (*enabled by default*)

src/configurationType.ts

@@ -245,7 +245,6 @@ export type Configuration = {
      * Wether to disable our and builtin method snippets within jsx attributes
      * @default true
      */
-    // TODO add smart setting
     'disableMethodSnippets.jsxAttributes': boolean
     /**
      * Support `@ts-diagnostic-disable` top-level comment for disabling spefici semantic diagnostics
@@ -271,10 +270,24 @@ export type Configuration = {
      */
     patchOutline: boolean
     /**
-     * Exclude covered strings/enum cases in switch
+     * Exclude covered strings/enum cases in switch in completions
      * @default true
      */
     switchExcludeCoveredCases: boolean
+    /**
+     * Make completions case-sensetive (see https://github.com/microsoft/TypeScript/issues/46622)
+     * Might be enabled by default in future. Experimental as for now compares only start of completions.
+     * Might require completion retrigger if was triggered by not quick suggestions.
+     * @default false
+     */
+    caseSensitiveCompletions: boolean
+    /**
+     * Might be useful to enable for a moment. Note, that you can bind shortcuts within VSCode to quickly toggle settings like this
+     * Also experimental and wasnt tested in all cases
+     * Like described in `caseSensitiveCompletions` might require completion retrigger
+     * @default false
+     */
+    disableFuzzyCompletions: boolean
     /**
      * Disable useless highlighting,
      * @default disable

typescript/src/completionsAtPosition.ts

@@ -20,6 +20,7 @@ import defaultHelpers from './completions/defaultHelpers'
 import objectLiteralCompletions from './completions/objectLiteralCompletions'
 import filterJsxElements from './completions/filterJsxComponents'
 import markOrRemoveGlobalCompletions from './completions/markOrRemoveGlobalCompletions'
+import { oneOf } from '@zardoy/utils'
 
 export type PrevCompletionMap = Record<string, { originalName?: string; documentationOverride?: string | ts.SymbolDisplayPart[] }>
 
@@ -92,11 +93,50 @@ export const getCompletionsAtPosition = (
 
     if (!prior) return
 
+    if (c('caseSensitiveCompletions')) {
+        const fullText = sourceFile.getFullText()
+        const currentWord = fullText.slice(0, position).match(/[\w\d]+$/)
+        if (currentWord) {
+            const firstEnteredChar = fullText.at(currentWord.index!) ?? ''
+            /** @returns -1 - lowercase, 1 - uppercase, 0 - ignore */
+            const getCharCasing = (char: string) => {
+                if (char.toLocaleUpperCase() !== char) return -1
+                if (char.toLocaleLowerCase() !== char) return 1
+                return 0
+            }
+            const typedStartCasing = getCharCasing(firstEnteredChar)
+            // check wether it is actually a case char and not a number for example
+            if (typedStartCasing !== 0) {
+                prior.entries = prior.entries.filter(entry => {
+                    const entryCasing = getCharCasing(entry.name.at(0) ?? '')
+                    if (entryCasing === 0) return true
+                    return entryCasing === typedStartCasing
+                })
+            }
+        }
+    }
+
+    if (c('disableFuzzyCompletions')) {
+        const fullText = sourceFile.getFullText()
+        const currentWord = fullText.slice(0, position).match(/[\w\d]+$/)
+        if (currentWord) {
+            prior.entries = prior.entries.filter(entry => {
+                if (entry.name.startsWith(currentWord[0])) return true
+                return false
+            })
+        }
+    }
+
     if (c('fixSuggestionsSorting')) prior.entries = fixPropertiesSorting(prior.entries, leftNode, sourceFile, program) ?? prior.entries
     if (node) prior.entries = boostKeywordSuggestions(prior.entries, position, node) ?? prior.entries
 
     const entryNames = new Set(prior.entries.map(({ name }) => name))
-    if (c('removeUselessFunctionProps.enable')) prior.entries = prior.entries.filter(e => !['Symbol', 'caller', 'prototype'].includes(e.name))
+    if (c('removeUselessFunctionProps.enable')) {
+        prior.entries = prior.entries.filter(entry => {
+            if (oneOf(entry.kind, ts.ScriptElementKind.warning)) return true
+            return !['Symbol', 'caller', 'prototype'].includes(entry.name)
+        })
+    }
     if (['bind', 'call', 'caller'].every(name => entryNames.has(name)) && c('highlightNonFunctionMethods.enable')) {
         const standardProps = new Set(['Symbol', 'apply', 'arguments', 'bind', 'call', 'caller', 'length', 'name', 'prototype', 'toString'])
         // TODO lift up!

typescript/test/completions.spec.ts

@@ -261,6 +261,26 @@ test('Switch Case Exclude Covered', () => {
     }
 })
 
+test('Case-sensetive completions', () => {
+    settingsOverride['caseSensitiveCompletions'] = true
+    const [_positivePositions, _negativePositions, numPositions] = fileContentsSpecialPositions(/* ts */ `
+        const a = {
+            TestItem: 5,
+            testItem: 5,
+            '3t': true
+            // not sure of these
+            // TestItemFoo: 5,
+            // TestItemfoo: 5,
+        }
+        a.t/*0*/
+        a['t/*0*/']
+    `)
+    for (const pos of numPositions) {
+        const { entryNames } = getCompletionsAtPosition(pos) ?? {}
+        expect(entryNames, pos.toString()).toEqual(['3t', 'testItem'])
+    }
+})
+
 test('Object Literal Completions', () => {
     const [_positivePositions, _negativePositions, numPositions] = fileContentsSpecialPositions(/* ts */ `
     interface Options {