👍 Add support for importMap property

This adds support for the `importMap` property in deno configuration
files. When a deno.json or deno.jsonc file with an `importMap` property,
the specified import map file will be loaded and used for module
resolution.

Author: Milly

deno.jsonc

@@ -15,6 +15,8 @@
   "exclude": [
     ".coverage/",
     "tests/denops/testdata/no_check/",
+    "tests/denops/testdata/with_deno_json/",
+    "tests/denops/testdata/with_deno_json2/",
     "tests/denops/testdata/with_import_map/"
   ],
   "imports": {

denops/@denops-private/plugin.ts

@@ -1,11 +1,13 @@
+import { isObjectOf } from "@core/unknownutil/is/object-of";
+import { isString } from "@core/unknownutil/is/string";
+import { isUndefined } from "@core/unknownutil/is/undefined";
 import type { Denops, Entrypoint } from "@denops/core";
 import {
   type ImportMap,
   ImportMapImporter,
   isImportMap,
   loadImportMap,
 } from "@lambdalisue/import-map-importer";
-import { ensure } from "@core/unknownutil";
 import { toFileUrl } from "@std/path/to-file-url";
 import { fromFileUrl } from "@std/path/from-file-url";
 import { parse as parseJsonc } from "@std/jsonc";
@@ -153,6 +155,19 @@ function isDenoCacheIssueError(e: unknown): boolean {
   return false;
 }
 
+async function loadJson(fileUrl: URL): Promise<unknown> {
+  const content = await Deno.readTextFile(fileUrl);
+  // Always parse as JSONC to be more permissive
+  return parseJsonc(content);
+}
+
+const hasImportMapProperty = isObjectOf({
+  importMap: isString,
+  // If `imports` or `scopes` exists, they will be override `importMap`
+  imports: isUndefined,
+  scopes: isUndefined,
+});
+
 async function tryLoadImportMap(
   scriptUrl: URL,
 ): Promise<ImportMap | undefined> {
@@ -167,22 +182,37 @@ async function tryLoadImportMap(
     "import_map.jsonc",
   ];
   for (const pattern of PATTERNS) {
-    const importMapUrl = new URL(pattern, scriptUrl);
-    const importMapPath = fromFileUrl(importMapUrl);
+    let importMapUrl = new URL(pattern, scriptUrl);
+
+    // Try to load the import map or deno configuration file
+    let jsonValue: unknown;
     try {
-      return await loadImportMap(importMapPath, {
-        loader: (path: string) => {
-          const content = Deno.readTextFileSync(path);
-          return ensure(parseJsonc(content), isImportMap);
-        },
-      });
+      jsonValue = await loadJson(importMapUrl);
     } catch (err: unknown) {
       if (err instanceof Deno.errors.NotFound) {
         // Ignore NotFound errors and try the next pattern
         continue;
       }
       throw err; // Rethrow other errors
     }
+
+    // Resolve import map path in the deno configuration and load it
+    if (
+      /\/deno\.jsonc?$/.test(importMapUrl.pathname) &&
+      hasImportMapProperty(jsonValue)
+    ) {
+      importMapUrl = new URL(jsonValue.importMap, importMapUrl);
+      jsonValue = await loadJson(importMapUrl);
+    }
+
+    // Resolve relative paths in the import map and return it
+    if (isImportMap(jsonValue)) {
+      const importMapPath = fromFileUrl(importMapUrl);
+      return await loadImportMap(importMapPath, { loader: () => jsonValue });
+    }
+
+    // If the file exists but has no import map, do not try the next pattern
+    break;
   }
   return undefined;
 }

denops/@denops-private/plugin_test.ts

@@ -27,6 +27,12 @@ const scriptInvalidConstraint2 = resolveTestDataURL(
 const scriptWithImportMap = resolveTestDataURL(
   "with_import_map/plugin_with_import_map.ts",
 );
+const scriptWithDenoJson = resolveTestDataURL(
+  "with_deno_json/plugin_with_deno_json.ts",
+);
+const scriptWithDenoJson2 = resolveTestDataURL(
+  "with_deno_json2/plugin_with_deno_json.ts",
+);
 
 Deno.test("Plugin", async (t) => {
   const meta: Meta = {
@@ -563,4 +569,85 @@ Deno.test("Plugin", async (t) => {
       });
     });
   });
+
+  await t.step("importMap property support", async (t) => {
+    await t.step("loads plugin with deno.json", async () => {
+      const denops = createDenops();
+      using _denops_call = stub(denops, "call");
+      using _denops_cmd = stub(denops, "cmd");
+
+      const plugin = new Plugin(denops, "test-plugin", scriptWithDenoJson);
+
+      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 'Deno json 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", scriptWithDenoJson);
+      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 'Relative import map works for test-plugin!'"],
+      });
+
+      // Should return the greeting from the mapped import
+      assertEquals(result, "Hello from relative import map!");
+    });
+
+    await t.step("importMap is overridden by imports", async () => {
+      const denops = createDenops();
+      using _denops_call = stub(denops, "call");
+      using _denops_cmd = stub(denops, "cmd");
+
+      const plugin = new Plugin(denops, "test-plugin", scriptWithDenoJson2);
+      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!");
+    });
+  });
 });

tests/denops/testdata/with_deno_json/deno.json

@@ -0,0 +1,3 @@
+{
+  "importMap": "./other_path/other_name.json"
+}

tests/denops/testdata/with_deno_json/other_path/helper.ts

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

tests/denops/testdata/with_deno_json/other_path/other_name.json

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

tests/denops/testdata/with_deno_json/plugin_with_deno_json.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 'Deno json plugin initialized'");
+};

tests/denops/testdata/with_deno_json2/deno.jsonc

@@ -0,0 +1,8 @@
+{
+  // `importMap` is defined, but ...
+  "importMap": "./other_path/other_name.json",
+  // `imports` is defined, so it will override the `importMap`
+  "imports": {
+    "@test/helper": "./helper.ts"
+  }
+}

tests/denops/testdata/with_deno_json2/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_deno_json2/other_path/helper.ts

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