Add import-map support in config

Author: Shougo

denops/ddc/app.ts

@@ -14,7 +14,7 @@ import type {
   UserOptions,
 } from "./types.ts";
 import { Loader } from "./loader.ts";
-import { isDenoCacheIssueError } from "./utils.ts";
+import { importPlugin, isDenoCacheIssueError } from "./utils.ts";
 import { createCallbackContext } from "./callback.ts";
 import { getFilter, getPreviewer, onCompleteDone, onEvent } from "./ext.ts";
 import type { BaseUi } from "./base/ui.ts";
@@ -27,7 +27,6 @@ import * as vars from "@denops/std/variable";
 import { ensure } from "@core/unknownutil/ensure";
 import { is } from "@core/unknownutil/is";
 import { Lock } from "@core/asyncutil/lock";
-import { toFileUrl } from "@std/path/to-file-url";
 
 export const main: Entrypoint = (denops: Denops) => {
   const loader = new Loader();
@@ -193,12 +192,9 @@ export const main: Entrypoint = (denops: Denops) => {
       await lock.lock(async () => {
         const path = ensure(arg1, is.String) as string;
         try {
-          // NOTE: Import module with fragment so that reload works properly.
-          // https://github.com/vim-denops/denops.vim/issues/227
-          const mod = await import(
-            `${toFileUrl(path).href}#${performance.now()}`
-          );
-          const obj = new mod.Config();
+          const mod = await importPlugin(path);
+          // deno-lint-ignore no-explicit-any
+          const obj = new (mod as any).Config();
           await obj.config({ denops, contextBuilder, setAlias });
         } catch (e) {
           if (isDenoCacheIssueError(e)) {

denops/ddc/deno.json

@@ -3,8 +3,9 @@
     "@core/asyncutil": "jsr:@core/asyncutil@~1.2.0",
     "@core/unknownutil": "jsr:@core/unknownutil@~4.3.0",
     "@denops/std": "jsr:@denops/std@~7.6.0",
-    "@std/async": "jsr:@std/async@~1.0.7",
+    "@lambdalisue/import-map-importer": "jsr:@lambdalisue/import-map-importer@~0.3.1",
     "@std/assert": "jsr:@std/assert@~1.0.7",
+    "@std/async": "jsr:@std/async@~1.0.7",
     "@std/path": "jsr:@std/path@~1.1.0",
     "@std/testing": "jsr:@std/testing@~1.0.0"
   }

denops/ddc/utils.ts

@@ -1,10 +1,19 @@
 import type { Callback } from "./types.ts";
 
-import type { Denops } from "@denops/std";
-import * as op from "@denops/std/option";
-
+import {
+  type ImportMap,
+  ImportMapImporter,
+  loadImportMap,
+} from "@lambdalisue/import-map-importer";
 import { is } from "@core/unknownutil/is";
 import { assertEquals } from "@std/assert/equals";
+import { toFileUrl } from "@std/path/to-file-url";
+import { fromFileUrl } from "@std/path/from-file-url";
+import { join } from "@std/path/join";
+import { dirname } from "@std/path/dirname";
+
+import type { Denops } from "@denops/std";
+import * as op from "@denops/std/option";
 
 export async function convertKeywordPattern(
   denops: Denops,
@@ -134,6 +143,51 @@ export async function callCallback(
   }
 }
 
+export async function tryLoadImportMap(
+  script: string,
+): Promise<ImportMap | undefined> {
+  if (script.startsWith("http://") || script.startsWith("https://")) {
+    // We cannot load import maps for remote scripts
+    return undefined;
+  }
+  const PATTERNS = [
+    "deno.json",
+    "deno.jsonc",
+    "import_map.json",
+    "import_map.jsonc",
+  ];
+  // Convert file URL to path for file operations
+  const scriptPath = script.startsWith("file://")
+    ? fromFileUrl(new URL(script))
+    : script;
+  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;
+}
+
+export async function importPlugin(path: string): Promise<unknown> {
+  const suffix = performance.now();
+  const url = toFileUrl(path).href;
+  const importMap = await tryLoadImportMap(path);
+  if (importMap) {
+    const importer = new ImportMapImporter(importMap);
+    return await importer.import(`${url}#${suffix}`);
+  } else {
+    return await import(`${url}#${suffix}`);
+  }
+}
+
 Deno.test("vimoption2ts", () => {
   assertEquals(vimoption2ts("@,48-57,_,\\"), "a-zA-Z0-9_\\\\");
   assertEquals(vimoption2ts("@,-,48-57,_"), "a-zA-Z0-9_-");

doc/ddc.txt

@@ -460,6 +460,8 @@ ddc#custom#load_config({path})
 		Load TypeScript configuration from {path} file.
 		NOTE: {path} must be full path.
 		NOTE: The loading is asynchronous.
+		NOTE: The "deno.json[c]" and "import_map.json[c]" files in the
+		same directory will also be loaded.
 
                                                    *ddc#custom#patch_buffer()*
 ddc#custom#patch_buffer({option-name}, {value})