Support import_map.json[c] in denops plugin directory

Now if the plugin has `import_map.json` or `import_map.jsonc` in the
same directory with `main.ts`, it will be loaded automatically and used
to resolve imports.

Author: lambdalisue

denops/@denops-private/plugin.ts

@@ -1,5 +1,15 @@
 import type { Denops, Entrypoint } from "jsr:@denops/core@^7.0.0";
+import {
+  type ImportMap,
+  ImportMapImporter,
+  isImportMap,
+  loadImportMap,
+} from "jsr:@lambdalisue/import-map-importer@^0.3.0";
 import { toFileUrl } from "jsr:@std/path@^1.0.2/to-file-url";
+import { join } from "jsr:@std/path@^1.0.2/join";
+import { dirname } from "jsr:@std/path@^1.0.2/dirname";
+import { parse } from "jsr:@std/[email protected]/parse";
+import { maybe } from "jsr:@core/unknownutil/maybe";
 
 type PluginModule = {
   main: Entrypoint;
@@ -26,10 +36,9 @@ export class Plugin {
   }
 
   async #load(): Promise<void> {
-    const suffix = createScriptSuffix(this.script);
     await emit(this.#denops, `DenopsSystemPluginPre:${this.name}`);
     try {
-      const mod: PluginModule = await import(`${this.script}${suffix}`);
+      const mod: PluginModule = await importPlugin(this.script);
       this.#disposable = await mod.main(this.#denops) ?? voidAsyncDisposable;
     } catch (e) {
       // Show a warning message when Deno module cache issue is detected
@@ -136,3 +145,39 @@ function isDenoCacheIssueError(e: unknown): boolean {
   }
   return false;
 }
+
+async function tryLoadImportMap(
+  scriptUrl: string,
+): Promise<ImportMap | undefined> {
+  const PATTERNS = [
+    "import_map.json",
+    "import_map.jsonc",
+  ];
+  // Convert file URL to path for file operations
+  const scriptPath = new URL(scriptUrl).pathname;
+  const parentDir = dirname(scriptPath);
+  for (const pattern of PATTERNS) {
+    const importMapPath = join(parentDir, pattern);
+    try {
+      return await loadImportMap(importMapPath);
+    } catch (err: unknown) {
+      if (err instanceof Deno.errors.NotFound) {
+        // Ignore NotFound errors and try the next pattern
+        continue;
+      }
+      throw err; // Rethrow other errors
+    }
+  }
+  return undefined;
+}
+
+async function importPlugin(script: string): Promise<PluginModule> {
+  const suffix = createScriptSuffix(script);
+  const importMap = await tryLoadImportMap(script);
+  if (importMap) {
+    const importer = new ImportMapImporter(importMap);
+    return await importer.import<PluginModule>(`${script}${suffix}`);
+  } else {
+    return await import(`${script}${suffix}`);
+  }
+}

denops/@denops-private/plugin_test.ts

@@ -29,6 +29,9 @@ const scriptInvalidConstraint = resolveTestDataURL(
 const scriptInvalidConstraint2 = resolveTestDataURL(
   "dummy_invalid_constraint_plugin2.ts",
 );
+const scriptWithImportMap = resolveTestDataURL(
+  "with_import_map/plugin_with_import_map.ts",
+);
 
 Deno.test("Plugin", async (t) => {
   const meta: Meta = {
@@ -490,4 +493,79 @@ Deno.test("Plugin", async (t) => {
       });
     });
   });
+
+  await t.step("import map support", async (t) => {
+    await t.step("loads plugin with import_map.json", async () => {
+      const denops = createDenops();
+      using _denops_call = stub(denops, "call");
+      using _denops_cmd = stub(denops, "cmd");
+
+      const plugin = new Plugin(denops, "test-plugin", scriptWithImportMap);
+
+      await plugin.waitLoaded();
+
+      // Should emit events
+      assertSpyCalls(_denops_call, 2);
+      assertSpyCall(_denops_call, 0, {
+        args: [
+          "denops#_internal#event#emit",
+          "DenopsSystemPluginPre:test-plugin",
+        ],
+      });
+      assertSpyCall(_denops_call, 1, {
+        args: [
+          "denops#_internal#event#emit",
+          "DenopsSystemPluginPost:test-plugin",
+        ],
+      });
+
+      // Should call the plugin's main function
+      assertSpyCalls(_denops_cmd, 1);
+      assertSpyCall(_denops_cmd, 0, {
+        args: ["echo 'Import map plugin initialized'"],
+      });
+    });
+
+    await t.step("plugin can use mapped imports", async () => {
+      const denops = createDenops();
+      using _denops_call = stub(denops, "call");
+      using _denops_cmd = stub(denops, "cmd");
+
+      const plugin = new Plugin(denops, "test-plugin", scriptWithImportMap);
+      await plugin.waitLoaded();
+
+      // Reset spy calls
+      _denops_cmd.calls.length = 0;
+
+      // Call the dispatcher function
+      const result = await plugin.call("test");
+
+      // Should execute the command with the message from the mapped import
+      assertSpyCalls(_denops_cmd, 1);
+      assertSpyCall(_denops_cmd, 0, {
+        args: ["echo 'Import map works for test-plugin!'"],
+      });
+
+      // Should return the greeting from the mapped import
+      assertEquals(result, "Hello from mapped import!");
+    });
+
+    await t.step("works without import map", async () => {
+      const denops = createDenops();
+      using _denops_call = stub(denops, "call");
+      using _denops_cmd = stub(denops, "cmd");
+
+      // Use a regular plugin without import map
+      const plugin = new Plugin(denops, "test-plugin", scriptValid);
+
+      await plugin.waitLoaded();
+
+      // Should load normally
+      assertSpyCalls(_denops_call, 2);
+      assertSpyCalls(_denops_cmd, 1);
+      assertSpyCall(_denops_cmd, 0, {
+        args: ["echo 'Hello, Denops!'"],
+      });
+    });
+  });
 });

tests/denops/testdata/with_import_map/helper.ts

@@ -0,0 +1,5 @@
+export const greeting = "Hello from mapped import!";
+
+export function getMessage(name: string): string {
+  return `Import map works for ${name}!`;
+}

tests/denops/testdata/with_import_map/import_map.json

@@ -0,0 +1,7 @@
+{
+  "imports": {
+    "@test/": "../",
+    "@test/lib": "../dummy_valid_plugin.ts",
+    "@test/helper": "./helper.ts"
+  }
+}

tests/denops/testdata/with_import_map/import_map.jsonc

@@ -0,0 +1,10 @@
+{
+  // This is a JSONC import map with comments
+  "imports": {
+    "@test/": "../",
+    // Map to a specific module
+    "@test/lib": "../dummy_valid_plugin.ts",
+    // Map to the helper module
+    "@test/helper": "./helper.ts"
+  }
+}

tests/denops/testdata/with_import_map/plugin_with_import_map.ts

@@ -0,0 +1,13 @@
+import type { Entrypoint } from "jsr:@denops/core@^7.0.0";
+import { getMessage, greeting } from "@test/helper";
+
+export const main: Entrypoint = async (denops) => {
+  denops.dispatcher = {
+    test: async () => {
+      const message = getMessage("test-plugin");
+      await denops.cmd(`echo '${message}'`);
+      return greeting;
+    },
+  };
+  await denops.cmd("echo 'Import map plugin initialized'");
+};