👍 Add waitLoaded() for waiting plugin load

Author: lambdalisue

denops/@denops-private/service.ts

@@ -6,41 +6,56 @@ import { toFileUrl } from "https://deno.land/std@0.217.0/path/mod.ts";
 import { toErrorObject } from "https://deno.land/x/errorutil@v0.1.1/mod.ts";
 import { DenopsImpl, Host } from "./denops.ts";
 
+// We can use `PromiseWithResolvers<void>` but Deno 1.38 doesn't have `PromiseWithResolvers`
+type Waiter = {
+  promise: Promise<void>;
+  resolve: () => void;
+};
+
 /**
  * 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();
   #meta: Meta;
   #host?: Host;
 
   constructor(meta: Meta) {
     this.#meta = meta;
   }
 
+  #getWaiter(name: string): Waiter {
+    if (!this.#waiters.has(name)) {
+      this.#waiters.set(name, Promise.withResolvers());
+    }
+    return this.#waiters.get(name)!;
+  }
+
   bind(host: Host): void {
     this.#host = host;
   }
 
-  load(
+  async load(
     name: string,
     script: string,
     suffix = "",
   ): Promise<void> {
     if (!this.#host) {
-      return Promise.reject(new Error("No host is bound to the service"));
+      throw new Error("No host is bound to the service");
     }
     let plugin = this.#plugins.get(name);
     if (plugin) {
       if (this.#meta.mode === "debug") {
         console.log(`A denops plugin '${name}' is already loaded. Skip`);
       }
-      return Promise.resolve();
+      return;
     }
     const denops = new DenopsImpl(name, this.#meta, this.#host, this);
     plugin = new Plugin(denops, name, script);
     this.#plugins.set(name, plugin);
-    return plugin.load(suffix);
+    await plugin.load(suffix);
+    this.#getWaiter(name).resolve();
   }
 
   reload(
@@ -54,12 +69,17 @@ export class Service implements Disposable {
       return Promise.resolve();
     }
     this.#plugins.delete(name);
+    this.#waiters.delete(name);
     // Import module with fragment so that reload works properly
     // https://github.com/vim-denops/denops.vim/issues/227
     const suffix = `#${performance.now()}`;
     return this.load(name, plugin.script, suffix);
   }
 
+  waitLoaded(name: string): Promise<void> {
+    return this.#getWaiter(name).promise;
+  }
+
   async #dispatch(name: string, fn: string, args: unknown[]): Promise<unknown> {
     const plugin = this.#plugins.get(name);
     if (!plugin) {

denops/@denops-private/service_test.ts

@@ -1,5 +1,6 @@
 import {
   assert,
+  assertEquals,
   assertMatch,
   assertRejects,
 } from "https://deno.land/std@0.217.0/assert/mod.ts";
@@ -9,9 +10,10 @@ import {
   stub,
 } from "https://deno.land/std@0.217.0/testing/mock.ts";
 import type { Meta } from "https://deno.land/x/denops_core@v6.0.5/mod.ts";
+import { promiseState } from "https://deno.land/x/async@v2.1.0/mod.ts";
+import { unimplemented } from "https://deno.land/x/errorutil@v0.1.1/mod.ts";
 import type { Host } from "./denops.ts";
 import { Service } from "./service.ts";
-import { unimplemented } from "https://deno.land/x/errorutil@v0.1.1/mod.ts";
 
 const scriptValid =
   new URL("./testdata/dummy_valid_plugin.ts", import.meta.url).href;
@@ -60,6 +62,15 @@ Deno.test("Service", async (t) => {
 
   service.bind(host);
 
+  const waitLoaded = service.waitLoaded("dummy");
+
+  await t.step(
+    "the result promise of waitLoaded() is 'pending' when the plugin is not loaded yet",
+    async () => {
+      assertEquals(await promiseState(waitLoaded), "pending");
+    },
+  );
+
   await t.step("load() loads plugin and emits autocmd events", async () => {
     const s = stub(host, "call");
     try {
@@ -91,6 +102,13 @@ Deno.test("Service", async (t) => {
     }
   });
 
+  await t.step(
+    "the result promise of waitLoaded() become 'fulfilled' when the plugin is loaded",
+    async () => {
+      assertEquals(await promiseState(waitLoaded), "fulfilled");
+    },
+  );
+
   await t.step(
     "load() loads plugin and emits autocmd events (failure)",
     async () => {