feat: debounce the inline completion

Author: hyrious

src/completion.ts

@@ -3,7 +3,7 @@ import { logger } from "./logger";
 import { ModelProviderManager } from "./providers";
 import { statusIcon } from "./status-icon";
 import { storage } from "./storage";
-import { getLanguageConfig } from "./utilities";
+import { getLanguageConfig, Queue } from "./utilities";
 
 /**
  * InlineCompletionProvider class provides inline completion functionality for the active document.
@@ -108,14 +108,25 @@ class InlineCompletionProvider implements vscode.InlineCompletionItemProvider {
     });
   }
 
+  private readonly queue = new Queue<vscode.InlineCompletionList>(500);
+  private async generateCompletions(
+    document: vscode.TextDocument,
+    position: vscode.Position,
+    abortController: AbortController,
+  ): Promise<vscode.InlineCompletionList> {
+    return this.queue.enqueue(() =>
+      this.doGenerateCompletions(document, position, abortController),
+    );
+  }
+
   /**
    * Generates completions for the current document.
    * @param {vscode.TextDocument} document - The current document.
    * @param {vscode.Position} position - The current position in the document.
    * @param {AbortController} abortController - The abort controller for the operation.
    * @returns {Promise<vscode.InlineCompletionList>} A list of inline completions.
    */
-  private async generateCompletions(
+  private async doGenerateCompletions(
     document: vscode.TextDocument,
     position: vscode.Position,
     abortController: AbortController,

src/utilities.ts

@@ -426,3 +426,49 @@ const LANGUAGES: { [key: string]: ILanguageConfig } = {
     comment: { start: "/* ", end: " */" },
   },
 };
+
+interface ITask<T> {
+  factory: () => Promise<T>;
+  resolve: (value: T) => void;
+  reject: (reason?: unknown) => void;
+}
+
+// Debounce an async function.
+export class Queue<T> {
+  private queue: ITask<T>[] = [];
+  private pending = false;
+
+  constructor(private readonly delay: number) {}
+
+  async enqueue(factory: () => Promise<T>): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+      this.queue.push({ factory, resolve, reject });
+      if (!this.pending) {
+        this.pending = true;
+        setTimeout(() => this.consume(), this.delay);
+      }
+    });
+  }
+
+  private consume() {
+    const { queue } = this;
+    this.queue = [];
+    const latest = queue.pop();
+    queue.forEach((task) => task.resolve([] as T));
+    if (latest) {
+      const promise = latest.factory();
+      promise.then(latest.resolve, latest.reject);
+      promise.then(
+        () => this.consumed(),
+        () => this.consumed(),
+      );
+    }
+    this.pending = false;
+  }
+
+  private consumed() {
+    if (this.queue.length) {
+      setTimeout(() => this.consume(), this.delay);
+    }
+  }
+}