Merge pull request #3 from overleaf/mj-unfiltered-at-end

Avoid re-arranging list of options when unfiltered results come in

Author: hrjakobsen

src/config.ts

@@ -90,6 +90,8 @@ export interface CompletionConfig {
   /// displaying results from faster sources. Defaults to 100
   /// milliseconds.
   updateSyncTime?: number
+  /// overleaf: Move unfiltered results after the filtered ones
+  unfilteredResultsAtEnd?: boolean
 }
 
 export const completionConfig = Facet.define<CompletionConfig, Required<CompletionConfig>>({
@@ -112,7 +114,9 @@ export const completionConfig = Facet.define<CompletionConfig, Required<Completi
       filterStrict: false,
       compareCompletions: (a, b) => a.label.localeCompare(b.label),
       interactionDelay: 75,
-      updateSyncTime: 100
+      updateSyncTime: 100,
+      // overleaf: default to at top which is default CM6 behaviour
+      unfilteredResultsAtEnd: false
     }, {
       defaultKeymap: (a, b) => a && b,
       closeOnBlur: (a, b) => a && b,

src/state.ts

@@ -33,7 +33,8 @@ function sortOptions(active: readonly ActiveSource[], state: EditorState) {
     let getMatch = a.result.getMatch
     if (a.result.filter === false) {
       for (let option of a.result.options) {
-        addOption(new Option(option, a.source, getMatch ? getMatch(option) : [], 1e9 - options.length))
+        let defaultScore = conf.unfilteredResultsAtEnd ? -1e9 : 1e9
+        addOption(new Option(option, a.source, getMatch ? getMatch(option) : [], defaultScore - options.length))
       }
     } else {
       let pattern = state.sliceDoc(a.from, a.to), match
@@ -59,31 +60,41 @@ function sortOptions(active: readonly ActiveSource[], state: EditorState) {
   }
 
   let result = [], prev = null
+  const priorityIndices = new Map<string, number>()
   let compare = conf.compareCompletions
   for (let opt of options.sort((a, b) => (b.score - a.score) || compare(a.completion, b.completion))) {
+    // overleaf: Deduplicate results with dedup options
+    //           The goal is to keep only the highest priority option, in the
+    //           highest scoring position.
+    const key = opt.completion.deduplicate?.key
+    if (key) {
+      // Handle merging specifically for deduplicated items item
+      const currentOptionIndex = priorityIndices.get(key)
+      if (currentOptionIndex === undefined) {
+        priorityIndices.set(key, result.length)
+        result.push(opt)
+        prev = opt.completion
+      } else {
+        if (result[currentOptionIndex].completion.deduplicate.priority < opt.completion.deduplicate.priority) {
+          result[currentOptionIndex] = opt
+          if (currentOptionIndex === result.length - 1) {
+            prev = opt.completion
+          }
+        }
+      }
+      continue
+    }
+    // overleaf: end
     let cur = opt.completion
     if (!prev || prev.label != cur.label) result.push(opt)
+    // overleaf: we're already handling deduplication, so skip extra merges
+    else if (prev.deduplicate) result.push(opt)
     else if (score(opt.completion) > score(prev)) result[result.length - 1] = opt
     else if (opt.completion.info) result[result.length - 1] = opt
     prev = opt.completion
   }
-  // overleaf: Deduplicate results with dedup options
-  const topPriorities = new Map<string, number>()
-  for (const opt of result) {
-    const key = opt.completion.deduplicate?.key
-    if (!key) continue
-    const currentPriority = topPriorities.get(key)
-    if (currentPriority === undefined) {
-      topPriorities.set(key, opt.completion.deduplicate.priority)
-    } else {
-      if (currentPriority < opt.completion.deduplicate.priority) {
-        topPriorities.set(key, opt.completion.deduplicate.priority)
-      }
-    }
-  }
-  return result.filter(opt => opt.completion.deduplicate
-      ? topPriorities.get(opt.completion.deduplicate.key) === opt.completion.deduplicate.priority
-      : true)
+
+  return result
 }
 
 class CompletionDialog {