Merge pull request #2 from overleaf/mj-upgrade-6-18-0

Upgrade to codemirror/autocomplete 6.18.0

Author: hrjakobsen

CHANGELOG.md

@@ -1,3 +1,65 @@
+## 6.18.0 (2024-08-05)
+
+### Bug fixes
+
+Style the info element so that newlines are preserved, to make it easier to display multi-line info from a string source.
+
+### New features
+
+When registering an `abort` handler for a completion query, you can now use the `onDocChange` option to indicate that your query should be aborted as soon as the document changes while it is running.
+
+## 6.17.0 (2024-07-03)
+
+### Bug fixes
+
+Fix an issue where completions weren't properly reset when starting a new completion through `activateOnCompletion`.
+
+### New features
+
+`CompletionContext` objects now have a `view` property that holds the editor view when the query context has a view available.
+
+## 6.16.3 (2024-06-19)
+
+### Bug fixes
+
+Avoid adding an `aria-autocomplete` attribute to the editor when there are no active sources active.
+
+## 6.16.2 (2024-05-31)
+
+### Bug fixes
+
+Allow backslash-escaped closing braces inside snippet field names/content.
+
+## 6.16.1 (2024-05-29)
+
+### Bug fixes
+
+Fix a bug where multiple backslashes before a brace in a snippet were all removed.
+
+## 6.16.0 (2024-04-12)
+
+### New features
+
+The new `activateOnCompletion` option allows autocompletion to be configured to chain completion activation for some types of completions.
+
+## 6.15.0 (2024-03-13)
+
+### New features
+
+The new `filterStrict` option can be used to turn off fuzzy matching of completions.
+
+## 6.14.0 (2024-03-10)
+
+### New features
+
+Completion results can now define a `map` method that can be used to adjust position-dependent information for document changes.
+
+## 6.13.0 (2024-02-29)
+
+### New features
+
+Completions may now provide 'commit characters' that, when typed, commit the completion before inserting the character.
+
 ## 6.12.0 (2024-01-12)
 
 ### Bug fixes

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemirror/autocomplete",
-  "version": "6.12.0",
+  "version": "6.18.0",
   "description": "Autocompletion for the CodeMirror code editor",
   "scripts": {
     "test": "cm-runtests",

src/closebrackets.ts

@@ -11,7 +11,7 @@ import {syntaxTree} from "@codemirror/language"
 export interface CloseBracketConfig {
   /// The opening brackets to close. Defaults to `["(", "[", "{", "'",
   /// '"']`. Brackets may be single characters or a triple of quotes
-  /// (as in `"''''"`).
+  /// (as in `"'''"`).
   brackets?: string[]
   /// Characters in front of which newly opened brackets are
   /// automatically closed. Closing always happens in front of

src/completion.ts

@@ -1,5 +1,5 @@
 import {EditorView} from "@codemirror/view"
-import {EditorState, StateEffect, Annotation, EditorSelection, TransactionSpec, Text} from "@codemirror/state"
+import {EditorState, StateEffect, Annotation, EditorSelection, TransactionSpec, Text, ChangeDesc} from "@codemirror/state"
 import {syntaxTree} from "@codemirror/language"
 import {SyntaxNode} from "@lezer/common"
 
@@ -39,6 +39,9 @@ export interface Completion {
   ///
   /// Multiple types can be provided by separating them with spaces.
   type?: string
+  /// When this option is selected, and one of these characters is
+  /// typed, insert the completion before typing the character.
+  commitCharacters?: readonly string[],
   /// When given, should be a number from -99 to 99 that adjusts how
   /// this completion is ranked compared to other completions that
   /// match the input as well as this one. A negative number moves it
@@ -86,6 +89,8 @@ export interface CompletionSection {
 export class CompletionContext {
   /// @internal
   abortListeners: (() => void)[] | null = []
+  /// @internal
+  abortOnDocChange = false
 
   /// Create a new completion context. (Mostly useful for testing
   /// completion sources—in the editor, the extension will create
@@ -99,7 +104,13 @@ export class CompletionContext {
     /// implicitly by typing. The usual way to respond to this is to
     /// only return completions when either there is part of a
     /// completable entity before the cursor, or `explicit` is true.
-    readonly explicit: boolean
+    readonly explicit: boolean,
+    /// The editor view. May be undefined if the context was created
+    /// in a situation where there is no such view available, such as
+    /// in synchronous updates via
+    /// [`CompletionResult.update`](#autocomplete.CompletionResult.update)
+    /// or when called by test code.
+    readonly view?: EditorView
   ) {}
 
   /// Get the extent, content, and (if there is a token) type of the
@@ -129,8 +140,19 @@ export class CompletionContext {
   /// Allows you to register abort handlers, which will be called when
   /// the query is
   /// [aborted](#autocomplete.CompletionContext.aborted).
-  addEventListener(type: "abort", listener: () => void) {
-    if (type == "abort" && this.abortListeners) this.abortListeners.push(listener)
+  ///
+  /// By default, running queries will not be aborted for regular
+  /// typing or backspacing, on the assumption that they are likely to
+  /// return a result with a
+  /// [`validFor`](#autocomplete.CompletionResult.validFor) field that
+  /// allows the result to be used after all. Passing `onDocChange:
+  /// true` will cause this query to be aborted for any document
+  /// change.
+  addEventListener(type: "abort", listener: () => void, options?: {onDocChange: boolean}) {
+    if (type == "abort" && this.abortListeners) {
+      this.abortListeners.push(listener)
+      if (options && options.onDocChange) this.abortOnDocChange = true
+    }
   }
 }
 
@@ -235,6 +257,16 @@ export interface CompletionResult {
   /// [`validFor`](#autocomplete.CompletionResult.validFor)) that the
   /// completion still applies in the new state.
   update?: (current: CompletionResult, from: number, to: number, context: CompletionContext) => CompletionResult | null
+  /// When results contain position-dependent information in, for
+  /// example, `apply` methods, you can provide this method to update
+  /// the result for transactions that happen after the query. It is
+  /// not necessary to update `from` and `to`—those are tracked
+  /// automatically.
+  map?: (current: CompletionResult, changes: ChangeDesc) => CompletionResult | null
+  /// Set a default set of [commit
+  /// characters](#autocomplete.Completion.commitCharacters) for all
+  /// options in this result.
+  commitCharacters?: readonly string[]
 }
 
 export class Option {

src/config.ts

@@ -7,6 +7,9 @@ export interface CompletionConfig {
   /// When enabled (defaults to true), autocompletion will start
   /// whenever the user types something that can be completed.
   activateOnTyping?: boolean
+  /// When given, if a completion that matches the predicate is
+  /// picked, reactivate completion again as if it was typed normally.
+  activateOnCompletion?: (completion: Completion) => boolean
   /// The amount of time to wait for further typing before querying
   /// completion sources via
   /// [`activateOnTyping`](#autocomplete.autocompletion^config.activateOnTyping).
@@ -72,6 +75,11 @@ export interface CompletionConfig {
   /// match score. Defaults to using
   /// [`localeCompare`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare).
   compareCompletions?: (a: Completion, b: Completion) => number
+  /// When set to true (the default is false), turn off fuzzy matching
+  /// of completions and only show those that start with the text the
+  /// user typed. Only takes effect for results where
+  /// [`filter`](#autocomplete.CompletionResult.filter) isn't false.
+  filterStrict?: boolean
   /// By default, commands relating to an open completion only take
   /// effect 75 milliseconds after the completion opened, so that key
   /// presses made before the user is aware of the tooltip don't go to
@@ -88,6 +96,7 @@ export const completionConfig = Facet.define<CompletionConfig, Required<Completi
   combine(configs) {
     return combineConfig<Required<CompletionConfig>>(configs, {
       activateOnTyping: true,
+      activateOnCompletion: () => false,
       activateOnTypingDelay: 100,
       selectOnOpen: true,
       override: null,
@@ -100,6 +109,7 @@ export const completionConfig = Facet.define<CompletionConfig, Required<Completi
       icons: true,
       addToOptions: [],
       positionInfo: defaultPositionInfo as any,
+      filterStrict: false,
       compareCompletions: (a, b) => a.label.localeCompare(b.label),
       interactionDelay: 75,
       updateSyncTime: 100
@@ -109,7 +119,8 @@ export const completionConfig = Facet.define<CompletionConfig, Required<Completi
       icons: (a, b) => a && b,
       tooltipClass: (a, b) => c => joinClass(a(c), b(c)),
       optionClass: (a, b) => c => joinClass(a(c), b(c)),
-      addToOptions: (a, b) => a.concat(b)
+      addToOptions: (a, b) => a.concat(b),
+      filterStrict: (a, b) => a || b,
     })
   }
 })

src/filter.ts

@@ -43,7 +43,7 @@ export class FuzzyMatcher {
   ret(score: number, matched: readonly number[]) {
     this.score = score
     this.matched = matched
-    return true
+    return this
   }
 
   // Matches a given word (completion) against the pattern (input).
@@ -53,9 +53,9 @@ export class FuzzyMatcher {
   //
   // The score is a number that is more negative the worse the match
   // is. See `Penalty` above.
-  match(word: string): boolean {
+  match(word: string): {score: number, matched: readonly number[]} | null {
     if (this.pattern.length == 0) return this.ret(Penalty.NotFull, [])
-    if (word.length < this.pattern.length) return false
+    if (word.length < this.pattern.length) return null
     let {chars, folded, any, precise, byWord} = this
     // For single-character queries, only match when they occur right
     // at the start
@@ -64,7 +64,7 @@ export class FuzzyMatcher {
       let score = firstSize == word.length ? 0 : Penalty.NotFull
       if (first == chars[0]) {}
       else if (first == folded[0]) score += Penalty.CaseFold
-      else return false
+      else return null
       return this.ret(score, [0, firstSize])
     }
     let direct = word.indexOf(this.pattern)
@@ -78,7 +78,7 @@ export class FuzzyMatcher {
         i += codePointSize(next)
       }
       // No match, exit immediately
-      if (anyTo < len) return false
+      if (anyTo < len) return null
     }
 
     // This tracks the extent of the precise (non-folded, not
@@ -129,7 +129,7 @@ export class FuzzyMatcher {
     if (byWordTo == len)
       return this.result(Penalty.ByWord + (byWordFolded ? Penalty.CaseFold : 0) + Penalty.NotStart +
         (wordAdjacent ? 0 : Penalty.Gap), byWord, word)
-    return chars.length == 2 ? false
+    return chars.length == 2 ? null
       : this.result((any[0] ? Penalty.NotStart : 0) + Penalty.CaseFold + Penalty.Gap, any, word)
   }
 
@@ -143,3 +143,24 @@ export class FuzzyMatcher {
     return this.ret(score - word.length, result)
   }
 }
+
+
+export class StrictMatcher {
+  matched: readonly number[] = []
+  score: number = 0
+  folded: string
+
+  constructor(readonly pattern: string) {
+    this.folded = pattern.toLowerCase()
+  }
+
+  match(word: string): {score: number, matched: readonly number[]} | null {
+    if (word.length < this.pattern.length) return null
+    let start = word.slice(0, this.pattern.length)
+    let match = start == this.pattern ? 0 : start.toLowerCase() == this.folded ? Penalty.CaseFold : null
+    if (match == null) return null
+    this.matched = [0, start.length]
+    this.score = match + (word.length == this.pattern.length ? 0 : Penalty.NotFull)
+    return this
+  }
+}

src/index.ts

@@ -3,7 +3,8 @@ import {keymap, KeyBinding} from "@codemirror/view"
 import {Completion, Option} from "./completion"
 import {completionState, State, setSelectedEffect} from "./state"
 import {CompletionConfig, completionConfig} from "./config"
-import {completionPlugin, moveCompletionSelection, acceptCompletion, startCompletion, closeCompletion} from "./view"
+import {completionPlugin, moveCompletionSelection, acceptCompletion,
+        startCompletion, closeCompletion, commitCharacters} from "./view"
 import {baseTheme} from "./theme"
 
 export {snippet, snippetCompletion, nextSnippetField, prevSnippetField,
@@ -18,6 +19,7 @@ export {getCompletionTooltip} from "./state"
 /// Returns an extension that enables autocompletion.
 export function autocompletion(config: CompletionConfig = {}): Extension {
   return [
+    commitCharacters,
     completionState,
     completionConfig.of(config),
     completionPlugin,

src/snippet.ts

@@ -46,10 +46,11 @@ class Snippet {
 
   static parse(template: string) {
     let fields: {seq: number | null, name: string}[] = []
-    let lines = [], positions = [], m
+    let lines = [], positions: FieldPos[] = [], m
     for (let line of template.split(/\r\n?|\n/)) {
-      while (m = /[#$]\{(?:(\d+)(?::([^}]*))?|([^}]*))\}/.exec(line)) {
-        let seq = m[1] ? +m[1] : null, name = m[2] || m[3] || "", found = -1
+      while (m = /[#$]\{(?:(\d+)(?::([^}]*))?|((?:\\[{}]|[^}])*))\}/.exec(line)) {
+        let seq = m[1] ? +m[1] : null, rawName = m[2] || m[3] || "", found = -1
+        let name = rawName.replace(/\\[{}]/g, m => m[1])
         for (let i = 0; i < fields.length; i++) {
           if (seq != null ? fields[i].seq == seq : name ? fields[i].name == name : false) found = i
         }
@@ -61,15 +62,15 @@ class Snippet {
           for (let pos of positions) if (pos.field >= found) pos.field++
         }
         positions.push(new FieldPos(found, lines.length, m.index, m.index + name.length))
-        line = line.slice(0, m.index) + name + line.slice(m.index + m[0].length)
+        line = line.slice(0, m.index) + rawName + line.slice(m.index + m[0].length)
       }
-      for (let esc; esc = /\\([{}])/.exec(line);) {
-        line = line.slice(0, esc.index) + esc[1] + line.slice(esc.index + esc[0].length)
-        for (let pos of positions) if (pos.line == lines.length && pos.from > esc.index) {
+      line = line.replace(/\\([{}])/g, (_, brace, index) => {
+        for (let pos of positions) if (pos.line == lines.length && pos.from > index) {
           pos.from--
           pos.to--
         }
-      }
+        return brace
+      })
       lines.push(line)
     }
     return new Snippet(lines, positions)