@esm.sh/import-map 0.2.0 → 0.2.1

package/README.md

@@ -1,12 +1,11 @@
 # @esm.sh/import-map
 
-An [Import Maps](https://wicg.github.io/import-maps/) manager.
+An [Import Maps](https://wicg.github.io/import-maps/) manager, with features:
 
-- create blank import maps
-- parse import maps from JSON/HTML
-- resolve specifiers with `imports` and `scopes`
-- add npm/jsr/github packages from [esm.sh](https://esm.sh) CDN into an import map
-- maintain optional `integrity` metadata
+- Parse import maps from JSON/HTML
+- Resolve specifiers to URLs using import map matching rules
+- Add npm/jsr/github modules from [esm.sh](https://esm.sh) CDN
+- Generate `integrity` entries for added modules
 
 ## Installation
 

package/dist/add.mjs

@@ -1,13 +1,4 @@
 import { satisfies, valid } from "semver";
-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 meta = await fetchImportMeta(cdnOrigin, imp, target);
-  const mark = /* @__PURE__ */ new Set();
-  await addImportMeta(importMap, mark, meta, false, void 0, cdnOrigin, target, noSRI ?? false);
-}
 const KNOWN_TARGETS = /* @__PURE__ */ new Set([
   "es2015",
   "es2016",
@@ -39,6 +30,111 @@ const ESM_SEGMENTS = /* @__PURE__ */ new Set([
 ]);
 const SPECIFIER_MARK_SEPARATOR = "\0";
 const META_CACHE = /* @__PURE__ */ new Map();
+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 meta = await fetchImportMeta(cdnOrigin, imp, target);
+  const mark = /* @__PURE__ */ new Set();
+  await addImportImpl(importMap, mark, meta, false, void 0, cdnOrigin, target, noSRI ?? false);
+}
+async function addImportImpl(importMap, mark, imp, indirect, targetImports, cdnOrigin, target, noSRI) {
+  const markedSpecifier = `${specifierOf(imp)}${SPECIFIER_MARK_SEPARATOR}${imp.version}`;
+  if (mark.has(markedSpecifier)) {
+    return;
+  }
+  mark.add(markedSpecifier);
+  const cdnScopeKey = `${cdnOrigin}/`;
+  const cdnScopeImports = importMap.scopes?.[cdnScopeKey];
+  const imports = indirect ? targetImports ?? ensureScope(importMap, cdnScopeKey) : importMap.imports;
+  const moduleUrl = moduleUrlOf(cdnOrigin, target, imp);
+  const currentSpecifier = specifierOf(imp);
+  imports[currentSpecifier] = moduleUrl;
+  await updateIntegrity(importMap, imp, moduleUrl, cdnOrigin, target, noSRI);
+  if (!indirect) {
+    if (cdnScopeImports) {
+      delete cdnScopeImports[currentSpecifier];
+    }
+    pruneEmptyScopes(importMap);
+  }
+  const allDeps = [
+    ...imp.peerImports.map((pathname) => ({ pathname, isPeer: true })),
+    ...imp.imports.map((pathname) => ({ pathname, isPeer: false }))
+  ];
+  await Promise.all(
+    allDeps.map(async ({ pathname, isPeer }) => {
+      if (pathname.startsWith("/node/")) {
+        return;
+      }
+      const depImport = parseEsmPath(pathname);
+      if (depImport.name === imp.name) {
+        depImport.version = imp.version;
+      }
+      const depSpecifier = specifierOf(depImport);
+      const existingUrl = importMap.imports[depSpecifier] ?? importMap.scopes?.[cdnScopeKey]?.[depSpecifier];
+      let scopedTargetImports = targetImports;
+      if (existingUrl?.startsWith(`${cdnOrigin}/`)) {
+        const existingImport = parseEsmPath(existingUrl);
+        const existingVersion = valid(existingImport.version);
+        if (existingVersion && depImport.version === existingImport.version) {
+          return;
+        }
+        if (existingVersion && depImport.version && !valid(depImport.version)) {
+          if (satisfies(existingVersion, depImport.version, { includePrerelease: true })) {
+            return;
+          }
+          if (isPeer) {
+            console.warn(
+              `incorrect peer dependency(unmeet ${depImport.version}): ${depImport.name}@${existingVersion}`
+            );
+            return;
+          }
+          const scope = `${cdnOrigin}/${esmSpecifierOf(imp)}/`;
+          scopedTargetImports = ensureScope(importMap, scope);
+        }
+      }
+      const depMeta = await fetchImportMeta(cdnOrigin, depImport, target);
+      await addImportImpl(importMap, mark, depMeta, !isPeer, scopedTargetImports, cdnOrigin, target, noSRI);
+    })
+  );
+  pruneEmptyScopes(importMap);
+}
+async function updateIntegrity(importMap, imp, moduleUrl, cdnOrigin, target, noSRI) {
+  if (noSRI) {
+    if (importMap.integrity) {
+      delete importMap.integrity[moduleUrl];
+      if (Object.keys(importMap.integrity).length === 0) {
+        delete importMap.integrity;
+      }
+    }
+    return;
+  }
+  if (!hasExternalImports(imp)) {
+    if (imp.integrity) {
+      importMap.integrity ??= {};
+      importMap.integrity[moduleUrl] = imp.integrity;
+    }
+    return;
+  }
+  const integrityMeta = await fetchImportMeta(
+    cdnOrigin,
+    {
+      name: imp.name,
+      version: imp.version,
+      subPath: imp.subPath,
+      github: imp.github,
+      jsr: imp.jsr,
+      external: true,
+      dev: imp.dev
+    },
+    target
+  );
+  if (integrityMeta.integrity) {
+    importMap.integrity ??= {};
+    importMap.integrity[moduleUrl] = integrityMeta.integrity;
+  }
+}
 function parseImportSpecifier(specifier) {
   let source = specifier.trim();
   const imp = {
@@ -174,102 +270,6 @@ async function fetchImportMeta(cdnOrigin, imp, target) {
     throw error;
   }
 }
-async function addImportMeta(importMap, mark, imp, indirect, targetImports, cdnOrigin, target, noSRI) {
-  const markedSpecifier = `${specifierOf(imp)}${SPECIFIER_MARK_SEPARATOR}${imp.version}`;
-  if (mark.has(markedSpecifier)) {
-    return;
-  }
-  mark.add(markedSpecifier);
-  const cdnScopeKey = `${cdnOrigin}/`;
-  const cdnScopeImports = importMap.scopes?.[cdnScopeKey];
-  const imports = indirect ? targetImports ?? ensureScope(importMap, cdnScopeKey) : importMap.imports;
-  const moduleUrl = moduleUrlOf(cdnOrigin, target, imp);
-  const currentSpecifier = specifierOf(imp);
-  imports[currentSpecifier] = moduleUrl;
-  await updateIntegrity(importMap, imp, moduleUrl, cdnOrigin, target, noSRI);
-  if (!indirect) {
-    if (cdnScopeImports) {
-      delete cdnScopeImports[currentSpecifier];
-    }
-    pruneEmptyScopes(importMap);
-  }
-  const allDeps = [
-    ...imp.peerImports.map((pathname) => ({ pathname, isPeer: true })),
-    ...imp.imports.map((pathname) => ({ pathname, isPeer: false }))
-  ];
-  await Promise.all(
-    allDeps.map(async ({ pathname, isPeer }) => {
-      if (pathname.startsWith("/node/")) {
-        return;
-      }
-      const depImport = parseEsmPath(pathname);
-      if (depImport.name === imp.name) {
-        depImport.version = imp.version;
-      }
-      const depSpecifier = specifierOf(depImport);
-      const existingUrl = importMap.imports[depSpecifier] ?? importMap.scopes?.[cdnScopeKey]?.[depSpecifier];
-      let scopedTargetImports = targetImports;
-      if (existingUrl?.startsWith(`${cdnOrigin}/`)) {
-        const existingImport = parseEsmPath(existingUrl);
-        const existingVersion = valid(existingImport.version);
-        if (existingVersion && depImport.version === existingImport.version) {
-          return;
-        }
-        if (existingVersion && depImport.version && !valid(depImport.version)) {
-          if (satisfies(existingVersion, depImport.version, { includePrerelease: true })) {
-            return;
-          }
-          if (isPeer) {
-            console.warn(
-              `incorrect peer dependency(unmeet ${depImport.version}): ${depImport.name}@${existingVersion}`
-            );
-            return;
-          }
-          const scope = `${cdnOrigin}/${esmSpecifierOf(imp)}/`;
-          scopedTargetImports = ensureScope(importMap, scope);
-        }
-      }
-      const depMeta = await fetchImportMeta(cdnOrigin, depImport, target);
-      await addImportMeta(importMap, mark, depMeta, !isPeer, scopedTargetImports, cdnOrigin, target, noSRI);
-    })
-  );
-  pruneEmptyScopes(importMap);
-}
-async function updateIntegrity(importMap, imp, moduleUrl, cdnOrigin, target, noSRI) {
-  if (noSRI) {
-    if (importMap.integrity) {
-      delete importMap.integrity[moduleUrl];
-      if (Object.keys(importMap.integrity).length === 0) {
-        delete importMap.integrity;
-      }
-    }
-    return;
-  }
-  if (!hasExternalImports(imp)) {
-    if (imp.integrity) {
-      importMap.integrity ??= {};
-      importMap.integrity[moduleUrl] = imp.integrity;
-    }
-    return;
-  }
-  const integrityMeta = await fetchImportMeta(
-    cdnOrigin,
-    {
-      name: imp.name,
-      version: imp.version,
-      subPath: imp.subPath,
-      github: imp.github,
-      jsr: imp.jsr,
-      external: true,
-      dev: imp.dev
-    },
-    target
-  );
-  if (integrityMeta.integrity) {
-    importMap.integrity ??= {};
-    importMap.integrity[moduleUrl] = integrityMeta.integrity;
-  }
-}
 function ensureScope(importMap, scopeKey) {
   importMap.scopes ??= {};
   importMap.scopes[scopeKey] ??= {};

package/dist/blank.mjs

@@ -1,6 +1,6 @@
 function createBlankImportMap(baseURL) {
   return {
-    baseURL: new URL(baseURL ?? ".", "file:///"),
+    baseURL: baseURL ? new URL(baseURL, "file:///") : void 0,
     imports: {}
   };
 }

package/dist/resolve.mjs

@@ -1,45 +1,63 @@
 function resolve(importMap, specifier, containingFile) {
-  const { baseURL, imports, scopes } = importMap;
-  const { origin, pathname } = new URL(containingFile, baseURL);
-  const sameOriginScopes = [];
-  for (const scopeName in scopes ?? {}) {
-    const scopeUrl = new URL(scopeName, baseURL);
-    if (scopeUrl.origin === origin) {
-      sameOriginScopes.push([scopeUrl.pathname, (scopes ?? {})[scopeName]]);
+  const baseURL = importMap.baseURL ?? new URL(globalThis.location?.href ?? "file:///");
+  const referrer = new URL(containingFile, baseURL);
+  const [specifierWithoutHash, hashPart = ""] = specifier.split("#", 2);
+  const [specifierWithoutQuery, queryPart = ""] = specifierWithoutHash.split("?", 2);
+  const hash = hashPart ? `#${hashPart}` : "";
+  const query = queryPart ? `?${queryPart}` : "";
+  const cleanSpecifier = specifierWithoutQuery;
+  const scopes = importMap.scopes ?? {};
+  const scopeEntries = Object.entries(scopes).map(([scopeKey, scopeImports]) => {
+    try {
+      return [new URL(scopeKey, baseURL).toString(), scopeImports];
+    } catch {
+      return [scopeKey, scopeImports];
     }
-  }
-  sameOriginScopes.sort(([a], [b]) => b.split("/").length - a.split("/").length);
-  if (sameOriginScopes.length > 0) {
-    for (const [scopePathname, scopeImports] of sameOriginScopes) {
-      if (pathname.startsWith(scopePathname)) {
-        const url = matchImport(specifier, scopeImports);
-        if (url) {
-          return [url, true];
-        }
-      }
+  }).sort((a, b) => compareScopeKeys(a[0], b[0]));
+  for (const [scopeKey, scopeImports] of scopeEntries) {
+    if (!referrer.toString().startsWith(scopeKey)) {
+      continue;
     }
-  }
-  if (origin === baseURL.origin) {
-    const url = matchImport(specifier, imports);
-    if (url) {
-      return [url, true];
+    const mapped2 = resolveWith(cleanSpecifier, scopeImports ?? {});
+    if (mapped2) {
+      return [normalizeUrl(baseURL, mapped2) + query + hash, true];
     }
   }
-  return [specifier, false];
+  const mapped = resolveWith(cleanSpecifier, importMap.imports);
+  if (mapped) {
+    return [normalizeUrl(baseURL, mapped) + query + hash, true];
+  }
+  return [cleanSpecifier + query + hash, false];
 }
-function matchImport(specifier, imports) {
-  if (specifier in imports) {
+function resolveWith(specifier, imports) {
+  if (imports[specifier]) {
     return imports[specifier];
   }
-  let bestMatch = null;
-  let bestKeyLength = -1;
-  for (const [k, v] of Object.entries(imports)) {
-    if (k.endsWith("/") && specifier.startsWith(k) && k.length > bestKeyLength) {
-      bestMatch = v + specifier.slice(k.length);
-      bestKeyLength = k.length;
+  if (!specifier.includes("/")) {
+    return null;
+  }
+  const prefixKeys = Object.keys(imports).filter((k) => k.endsWith("/") && specifier.startsWith(k)).sort((a, b) => b.length - a.length || (a < b ? 1 : -1));
+  for (const key of prefixKeys) {
+    const value = imports[key];
+    if (value && value.endsWith("/")) {
+      return value + specifier.slice(key.length);
     }
   }
-  return bestMatch;
+  return null;
+}
+function compareScopeKeys(a, b) {
+  const aSlashCount = a.split("/").length;
+  const bSlashCount = b.split("/").length;
+  if (aSlashCount !== bSlashCount) {
+    return bSlashCount - aSlashCount;
+  }
+  return a < b ? 1 : -1;
+}
+function normalizeUrl(baseURL, path) {
+  if (path.startsWith("/") || path.startsWith("./") || path.startsWith("../")) {
+    return new URL(path, baseURL).toString();
+  }
+  return path;
 }
 export {
   resolve

package/package.json

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

package/types/index.d.ts

@@ -1,6 +1,6 @@
 /** The import maps follow the spec at https://wicg.github.io/import-maps/. */
 export interface ImportMap {
-  baseURL: URL;
+  baseURL?: URL;
   config?: Record<string, string>;
   imports: Record<string, string>;
   scopes?: Record<string, Record<string, string>>;