👍 Add denops#interrupt() function

autoload/denops.vim

@@ -25,6 +25,14 @@ function! denops#request_async(name, method, params, success, failure) abort
         \)
 endfunction
 
+function! denops#interrupt(...) abort
+  let l:args = a:0 ? [a:1] : []
+  call denops#_internal#server#chan#notify(
+        \ 'invoke',
+        \ ['interrupt', l:args],
+        \)
+endfunction
+
 " Configuration
 call denops#_internal#conf#define('denops#disabled', 0)
 call denops#_internal#conf#define('denops#deno', 'deno')

denops/@denops-private/denops.ts

@@ -13,7 +13,10 @@ const isBatchReturn = is.TupleOf([is.Array, is.String] as const);
 
 export type Host = Pick<HostOrigin, "redraw" | "call" | "batch">;
 
-export type Service = Pick<ServiceOrigin, "dispatch" | "waitLoaded">;
+export type Service = Pick<
+  ServiceOrigin,
+  "dispatch" | "waitLoaded" | "interrupted"
+>;
 
 export class DenopsImpl implements Denops {
   readonly name: string;
@@ -37,6 +40,10 @@ export class DenopsImpl implements Denops {
     this.#service = service;
   }
 
+  get interrupted(): AbortSignal {
+    return this.#service.interrupted;
+  }
+
   redraw(force?: boolean): Promise<void> {
     return this.#host.redraw(force);
   }

denops/@denops-private/denops_test.ts

@@ -23,6 +23,7 @@ Deno.test("DenopsImpl", async (t) => {
   const service: Service = {
     dispatch: () => unimplemented(),
     waitLoaded: () => unimplemented(),
+    interrupted: new AbortController().signal,
   };
   const denops = new DenopsImpl("dummy", meta, host, service);
 

denops/@denops-private/host.ts

@@ -50,6 +50,7 @@ export type Service = {
   bind(host: Host): void;
   load(name: string, script: string): Promise<void>;
   reload(name: string): Promise<void>;
+  interrupt(reason?: unknown): void;
   dispatch(name: string, fn: string, args: unknown[]): Promise<unknown>;
   dispatchAsync(
     name: string,
@@ -74,6 +75,11 @@ export function invoke(
       return service.reload(
         ...ensure(args, is.TupleOf([is.String] as const)),
       );
+    case "interrupt":
+      service.interrupt(
+        ...ensure(args, is.ParametersOf([is.OptionalOf(is.Unknown)] as const)),
+      );
+      return Promise.resolve();
     case "dispatch":
       return service.dispatch(
         ...ensure(args, is.TupleOf([is.String, is.String, is.Array] as const)),

denops/@denops-private/host/nvim_test.ts

@@ -21,6 +21,7 @@ Deno.test("Neovim", async (t) => {
         bind: () => unimplemented(),
         load: () => unimplemented(),
         reload: () => unimplemented(),
+        interrupt: () => unimplemented(),
         dispatch: () => unimplemented(),
         dispatchAsync: () => unimplemented(),
       };

denops/@denops-private/host/vim_test.ts

@@ -22,6 +22,7 @@ Deno.test("Vim", async (t) => {
         bind: () => unimplemented(),
         load: () => unimplemented(),
         reload: () => unimplemented(),
+        interrupt: () => unimplemented(),
         dispatch: () => unimplemented(),
         dispatchAsync: () => unimplemented(),
       };

denops/@denops-private/host_test.ts

@@ -12,6 +12,7 @@ Deno.test("invoke", async (t) => {
   const service: Omit<Service, "bind"> = {
     load: () => unimplemented(),
     reload: () => unimplemented(),
+    interrupt: () => unimplemented(),
     dispatch: () => unimplemented(),
     dispatchAsync: () => unimplemented(),
   };

denops/@denops-private/service.ts

@@ -16,8 +16,9 @@ type Waiter = {
  * Service manage plugins and is visible from the host (Vim/Neovim) through `invoke()` function.
  */
 export class Service implements Disposable {
-  #plugins: Map<string, Plugin> = new Map();
-  #waiters: Map<string, Waiter> = new Map();
+  #interruptController = new AbortController();
+  #plugins = new Map<string, Plugin>();
+  #waiters = new Map<string, Waiter>();
   #meta: Meta;
   #host?: Host;
 
@@ -32,6 +33,10 @@ export class Service implements Disposable {
     return this.#waiters.get(name)!;
   }
 
+  get interrupted(): AbortSignal {
+    return this.#interruptController.signal;
+  }
+
   bind(host: Host): void {
     this.#host = host;
   }
@@ -80,6 +85,11 @@ export class Service implements Disposable {
     return this.#getWaiter(name).promise;
   }
 
+  interrupt(reason?: unknown): void {
+    this.#interruptController.abort(reason);
+    this.#interruptController = new AbortController();
+  }
+
   async #dispatch(name: string, fn: string, args: unknown[]): Promise<unknown> {
     const plugin = this.#plugins.get(name);
     if (!plugin) {