@esm.sh/import-map 0.3.1 → 0.4.0

package/README.md

@@ -15,7 +15,7 @@ npm i @esm.sh/import-map
 
 ## API
 
-### `new ImportMap(baseURL?: string, raw?: ImportMapRaw)`
+### `new ImportMap(init?: ImportMapRaw, baseURL?: string)`
 
 Create an import map instance:
 
@@ -28,7 +28,7 @@ const im = new ImportMap();
 You can also initialize from a raw object:
 
 ```ts
-const im = new ImportMap("https://example.com/app/", {
+const im = new ImportMap({
   config: { cdn: "https://esm.sh", target: "es2022" },
   imports: { react: "https://esm.sh/react@19.2.4/es2022/react.mjs" },
   scopes: {
@@ -99,6 +99,19 @@ const im = new ImportMap();
 await im.addImport("react-dom@19/client");
 ```
 
+### `setFetcher(fetcher: (url: string | URL) => Promise<Response>)`
+
+Override the default `fetch` used internally by `addImport`.
+This is useful for caching metadata responses, or to use a custom fetch implementation.
+
+```ts
+// Use a custom fetch with cache.
+setFetcher(cacheFetch);
+
+// Restore default behavior.
+setFetcher(globalThis.fetch);
+```
+
 ### `ImportMap.resolve(specifier: string, containingFile: string)`
 
 The `resolve` method resolves a specifier using import-map matching rules:

package/dist/index.mjs

@@ -35,18 +35,20 @@ async function addImport(importMap, specifier, noSRI) {
   const imp = parseImportSpecifier(specifier);
   const config = importMap.config ?? {};
   const target = normalizeTarget(config.target);
-  const cdnOrigin = getCdnOrigin(config.cdn);
+  const cdnOrigin = normalizeCdnOrigin(config.cdn);
   const meta = await fetchImportMeta(cdnOrigin, imp, target);
   const mark = /* @__PURE__ */ new Set();
   await addImportImpl(importMap, mark, meta, false, void 0, cdnOrigin, target, noSRI ?? false);
+  pruneScopeSpecifiersShadowedByImports(importMap);
+  pruneEmptyScopes(importMap);
 }
 async function addImportImpl(importMap, mark, imp, indirect, targetImports, cdnOrigin, target, noSRI) {
-  const markedSpecifier = `${specifierOf(imp)}${SPECIFIER_MARK_SEPARATOR}${imp.version}`;
+  const markedSpecifier = specifierOf(imp) + SPECIFIER_MARK_SEPARATOR + imp.version;
   if (mark.has(markedSpecifier)) {
     return;
   }
   mark.add(markedSpecifier);
-  const cdnScopeKey = `${cdnOrigin}/`;
+  const cdnScopeKey = cdnOrigin + "/";
   const cdnScopeImports = importMap.scopes?.[cdnScopeKey];
   const imports = indirect ? targetImports ?? ensureScope(importMap, cdnScopeKey) : importMap.imports;
   const moduleUrl = moduleUrlOf(cdnOrigin, target, imp);
@@ -75,7 +77,7 @@ async function addImportImpl(importMap, mark, imp, indirect, targetImports, cdnO
       const depSpecifier = specifierOf(depImport);
       const existingUrl = importMap.imports[depSpecifier] ?? importMap.scopes?.[cdnScopeKey]?.[depSpecifier];
       let scopedTargetImports = targetImports;
-      if (existingUrl?.startsWith(`${cdnOrigin}/`)) {
+      if (existingUrl?.startsWith(cdnOrigin + "/")) {
         const existingImport = parseEsmPath(existingUrl);
         const existingVersion = valid(existingImport.version);
         if (existingVersion && depImport.version === existingImport.version) {
@@ -87,11 +89,11 @@ async function addImportImpl(importMap, mark, imp, indirect, targetImports, cdnO
           }
           if (isPeer) {
             console.warn(
-              `incorrect peer dependency(unmeet ${depImport.version}): ${depImport.name}@${existingVersion}`
+              "incorrect peer dependency(unmeet " + depImport.version + "): " + depImport.name + "@" + existingVersion
             );
             return;
           }
-          const scope = `${cdnOrigin}/${esmSpecifierOf(imp)}/`;
+          const scope = cdnOrigin + "/" + esmSpecifierOf(imp) + "/";
           scopedTargetImports = ensureScope(importMap, scope);
         }
       }
@@ -159,10 +161,10 @@ function parseImportSpecifier(specifier) {
   [packageAndVersion, imp.subPath] = splitByFirst(source, "/");
   [imp.name, imp.version] = splitByFirst(packageAndVersion, "@");
   if (scopeName) {
-    imp.name = `${scopeName}/${imp.name}`;
+    imp.name = scopeName + "/" + imp.name;
   }
   if (!imp.name) {
-    throw new Error(`invalid package name or version: ${specifier}`);
+    throw new Error("invalid package name or version: " + specifier);
   }
   return imp;
 }
@@ -172,20 +174,24 @@ function normalizeTarget(target) {
   }
   return "es2022";
 }
-function getCdnOrigin(cdn) {
+function normalizeCdnOrigin(cdn) {
   if (cdn && (cdn.startsWith("https://") || cdn.startsWith("http://"))) {
-    return cdn.replace(/\/+$/, "");
+    try {
+      return new URL(cdn).origin;
+    } catch (error) {
+      console.warn("invalid cdn: " + cdn);
+    }
   }
   return "https://esm.sh";
 }
 function specifierOf(imp) {
   const prefix = imp.github ? "gh:" : imp.jsr ? "jsr:" : "";
-  return `${prefix}${imp.name}${imp.subPath ? `/${imp.subPath}` : ""}`;
+  return prefix + imp.name + (imp.subPath ? "/" + imp.subPath : "");
 }
 function esmSpecifierOf(imp) {
   const prefix = imp.github ? "gh/" : imp.jsr ? "jsr/" : "";
   const external = hasExternalImports(imp) ? "*" : "";
-  return `${prefix}${external}${imp.name}@${imp.version}`;
+  return prefix + external + imp.name + "@" + imp.version;
 }
 function registryPrefix(imp) {
   if (imp.github) {
@@ -201,49 +207,53 @@ function hasExternalImports(meta) {
     return true;
   }
   for (const dep of meta.imports) {
-    if (!dep.startsWith("/node/") && !dep.startsWith(`/${meta.name}@`)) {
+    if (!dep.startsWith("/node/") && !dep.startsWith("/" + meta.name + "@")) {
       return true;
     }
   }
   return false;
 }
 function moduleUrlOf(cdnOrigin, target, imp) {
-  let url = `${cdnOrigin}/${esmSpecifierOf(imp)}/${target}/`;
+  let url = cdnOrigin + "/" + esmSpecifierOf(imp) + "/" + target + "/";
   if (imp.subPath) {
     if (imp.dev || imp.subPath === "jsx-dev-runtime") {
-      url += `${imp.subPath}.development.mjs`;
+      url += imp.subPath + ".development.mjs";
     } else {
-      url += `${imp.subPath}.mjs`;
+      url += imp.subPath + ".mjs";
     }
     return url;
   }
   const fileName = imp.name.includes("/") ? imp.name.split("/").at(-1) : imp.name;
-  return `${url}${fileName}.mjs`;
+  return url + fileName + ".mjs";
+}
+var fetcher = globalThis.fetch;
+function setFetcher(f) {
+  fetcher = f;
 }
 async function fetchImportMeta(cdnOrigin, imp, target) {
   const star = imp.external ? "*" : "";
-  const version = imp.version ? `@${imp.version}` : "";
-  const subPath = imp.subPath ? `/${imp.subPath}` : "";
-  const targetQuery = target !== "es2022" ? `&target=${encodeURIComponent(target)}` : "";
-  const url = `${cdnOrigin}/${star}${registryPrefix(imp)}${imp.name}${version}${subPath}?meta${targetQuery}`;
+  const version = imp.version ? "@" + imp.version : "";
+  const subPath = imp.subPath ? "/" + imp.subPath : "";
+  const targetQuery = target !== "es2022" ? "&target=" + encodeURIComponent(target) : "";
+  const url = cdnOrigin + "/" + star + registryPrefix(imp) + imp.name + version + subPath + "?meta" + targetQuery;
   const cached = META_CACHE.get(url);
   if (cached) {
     return cached;
   }
   const pending = (async () => {
-    const res = await fetch(url);
+    const res = await fetcher(url);
     if (res.status === 404) {
-      throw new Error(`package not found: ${imp.name}${version}${subPath}`);
+      throw new Error("package not found: " + imp.name + version + subPath);
     }
     if (!res.ok) {
-      throw new Error(`unexpected http status ${res.status}: ${await res.text()}`);
+      throw new Error("unexpected http status " + res.status + ": " + await res.text());
     }
     const bodyText = await res.text();
     let data;
     try {
       data = JSON.parse(bodyText);
-    } catch {
-      throw new Error(`invalid meta response from ${url}: ${bodyText.slice(0, 200)}`);
+    } catch (error) {
+      throw new Error("invalid meta response from " + url + ": " + String(error));
     }
     return {
       name: data.name ?? imp.name,
@@ -283,6 +293,20 @@ function pruneEmptyScopes(importMap) {
     }
   }
 }
+function pruneScopeSpecifiersShadowedByImports(importMap) {
+  for (const [scopeKey, scopedImports] of Object.entries(importMap.scopes)) {
+    if (scopeKey.startsWith("https://") || scopeKey.startsWith("http://")) {
+      const url = new URL(scopeKey);
+      if (url.pathname === "/") {
+        for (const specifier of Object.keys(scopedImports)) {
+          if (specifier in importMap.imports) {
+            delete scopedImports[specifier];
+          }
+        }
+      }
+    }
+  }
+}
 function parseEsmPath(pathnameOrUrl) {
   let pathname;
   if (pathnameOrUrl.startsWith("https://") || pathnameOrUrl.startsWith("http://")) {
@@ -290,7 +314,7 @@ function parseEsmPath(pathnameOrUrl) {
   } else if (pathnameOrUrl.startsWith("/")) {
     pathname = splitByFirst(splitByFirst(pathnameOrUrl, "#")[0], "?")[0];
   } else {
-    throw new Error(`invalid pathname or url: ${pathnameOrUrl}`);
+    throw new Error("invalid pathname or url: " + pathnameOrUrl);
   }
   const imp = {
     name: "",
@@ -310,19 +334,19 @@ function parseEsmPath(pathnameOrUrl) {
   }
   const segs = pathname.split("/").filter(Boolean);
   if (segs.length === 0) {
-    throw new Error(`invalid pathname: ${pathnameOrUrl}`);
+    throw new Error("invalid pathname: " + pathnameOrUrl);
   }
   if (segs[0].startsWith("@")) {
     if (!segs[1]) {
-      throw new Error(`invalid pathname: ${pathnameOrUrl}`);
+      throw new Error("invalid pathname: " + pathnameOrUrl);
     }
     const [name, version] = splitByLast(segs[1], "@");
-    imp.name = `${segs[0]}/${name}`.replace(/^\*/, "");
+    imp.name = trimLeadingStar(segs[0] + "/" + name);
     imp.version = version;
     segs.splice(0, 2);
   } else {
     const [name, version] = splitByLast(segs[0], "@");
-    imp.name = name.replace(/^\*/, "");
+    imp.name = trimLeadingStar(name);
     imp.version = version;
     segs.splice(0, 1);
   }
@@ -341,7 +365,7 @@ function parseEsmPath(pathnameOrUrl) {
         subPath = subPath.slice(0, -12);
         imp.dev = true;
       }
-      if (subPath.includes("/") || subPath !== imp.name && !imp.name.endsWith(`/${subPath}`)) {
+      if (subPath.includes("/") || subPath !== imp.name && !imp.name.endsWith("/" + subPath)) {
         imp.subPath = subPath;
       }
     } else {
@@ -350,6 +374,12 @@ function parseEsmPath(pathnameOrUrl) {
   }
   return imp;
 }
+function trimLeadingStar(value) {
+  if (value.startsWith("*")) {
+    return value.slice(1);
+  }
+  return value;
+}
 function splitByFirst(value, separator) {
   const idx = value.indexOf(separator);
   if (idx < 0) {
@@ -464,7 +494,7 @@ var ImportMap = class {
   imports = {};
   scopes = {};
   integrity = {};
-  constructor(baseURL, init) {
+  constructor(init, baseURL) {
     this.#baseURL = new URL(baseURL ?? globalThis.location?.href ?? "file:///");
     if (init) {
       this.config = sanitizeStringMap(init.config);
@@ -527,7 +557,7 @@ function sortScopes(scopes) {
 
 // src/parse.ts
 function parseFromJson(json, baseURL) {
-  const im = new ImportMap(baseURL);
+  const im = new ImportMap({}, baseURL);
   const v = JSON.parse(json);
   if (isObject(v)) {
     const { config, imports, scopes, integrity } = v;
@@ -545,7 +575,7 @@ function parseFromHtml(html, baseURL) {
   if (scriptEl) {
     return parseFromJson(scriptEl.textContent, baseURL);
   }
-  return new ImportMap(baseURL);
+  return new ImportMap({}, baseURL);
 }
 
 // src/support.ts
@@ -556,5 +586,6 @@ export {
   ImportMap,
   isSupportImportMap,
   parseFromHtml,
-  parseFromJson
+  parseFromJson,
+  setFetcher
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esm.sh/import-map",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "A import map parser and resolver.",
   "type": "module",
   "main": "./dist/index.mjs",

package/types/index.d.ts

@@ -25,7 +25,7 @@ export interface ImportMapRaw {
 
 /** The import map class. */
 export class ImportMap {
-  constructor(baseURL?: string | URL, init?: Record<string, any>);
+  constructor(init?: Record<string, any>, baseURL?: string | URL);
 
   /** The config for generating the new import url from CDN. */
   config: ImportMapConfig;
@@ -66,3 +66,6 @@ export function parseFromHtml(html: string, baseURL?: string): ImportMap;
 
 /** Check if current browser supports import maps. */
 export function isSupportImportMap(): boolean;
+
+/** Set the fetcher to use for fetching import meta. */
+export function setFetcher(fetcher: (url: string | URL) => Promise<Response>): void;