@jsenv/import-map - npm Package Compare versions

Comparing version 3.1.0 to 4.0.0

dist/commonjs/main.js

@@ -376,72 +376,91 @@ 'use strict';
   assertImportMap(importMap);
-  var folderPattern = "/".concat(folderRelativeName, "/");
+  var into = "/".concat(folderRelativeName, "/");
   var imports = importMap.imports,
       scopes = importMap.scopes;
-  var importsWrapped = imports ? prefixImports(imports, folderPattern) : {};
-  var scopesWrapped = scopes ? prefixScopes(scopes, folderPattern) : {};
+  var importsForWrapping;
+  var scopesForWrapping;
 
-  if (imports && "/" in imports) {
-    scopesWrapped[folderPattern] = _defineProperty({}, folderPattern, folderPattern);
+  if (scopes) {
+    scopesForWrapping = {};
+    Object.keys(scopes).forEach(function (scopeKey) {
+      var scopeValue = scopes[scopeKey];
+      var scopeKeyPrefixed = wrapSpecifier(scopeKey, into);
+
+      if (scopeKeyPrefixed === scopeKey) {
+        scopesForWrapping[scopeKey] = scopeValue;
+      } else {
+        scopesForWrapping[scopeKeyPrefixed] = wrapImports(scopeValue, into);
+      }
+    });
+  } else {
+    scopesForWrapping = {};
   }
 
+  if (imports) {
+    importsForWrapping = wrapImports(imports, into);
+    scopesForWrapping[into] = wrapImports(imports, into);
+  } else {
+    importsForWrapping = {};
+    scopesForWrapping[into] = {};
+  } // ensure anything not directly remapped is remapped inside into
+
+
+  importsForWrapping[into] = into;
+  importsForWrapping["/"] = into; // and when already into, you stay inside
+
+  scopesForWrapping[into]["/"] = "/";
   return {
-    imports: importsWrapped,
-    scopes: scopesWrapped
+    imports: importsForWrapping,
+    scopes: scopesForWrapping
   };
-}; // this function must make sure it returns imports so that
-// Object.keys(imports).indexOf('/') === Object.keys(imports).length - 1
-// Object.keys(imports).indexOf(folderPattern) === Object.keys(imports).length - 2
-// even if imports already contains '/' or folderPattern
-
-var ensureLeadingSlashImportWrapped = function ensureLeadingSlashImportWrapped(imports, folderPattern) {
-  var wrappedImports = {};
-  Object.keys(imports).forEach(function (key) {
-    if (key === "/" || key === folderPattern) return;
-    wrappedImports[key] = imports[key];
-  });
-  wrappedImports[folderPattern] = folderPattern;
-  wrappedImports["/"] = folderPattern;
-  return wrappedImports;
 };
 
-var prefixImports = function prefixImports(imports, folderPattern) {
-  var importsPrefixed = {};
+var wrapImports = function wrapImports(imports, into) {
+  var importsWithKeyWrapped = {};
+  var importsRemaining = {};
   Object.keys(imports).forEach(function (importKey) {
     var importValue = imports[importKey];
+    var importKeyWrapped = wrapSpecifier(importKey, into);
+    var importValueWrapped = wrapSpecifier(importValue, into);
 
-    if (importValue === "/") {
-      importsPrefixed[folderPattern] = folderPattern;
+    if (importKeyWrapped === importKey) {
+      importsRemaining[importKey] = importValue;
+    } else if (importValueWrapped === importValue) {
+      importsWithKeyWrapped[importKeyWrapped] = importValue;
+    } else {
+      importsWithKeyWrapped[importKeyWrapped] = importValueWrapped;
+      importsRemaining[importKey] = importValueWrapped;
     }
+  });
 
-    if (importValue[0] === "/") {
-      importsPrefixed[importKey] = "".concat(folderPattern).concat(importValue.slice(1));
-    }
-  });
-  return importsPrefixed;
+  var importsWrapped = _objectSpread2({}, importsWithKeyWrapped, {}, importsRemaining);
+
+  return importsWrapped;
 };
 
-var prefixScopes = function prefixScopes(scopes, folderPattern) {
-  var scopesPrefixed = {};
-  Object.keys(scopes).forEach(function (scopeKey) {
-    if (scopeKey[0] === "/") {
-      var scopeValue = scopes[scopeKey];
-      var prefixedScopeKey = "".concat(folderPattern).concat(scopeKey.slice(1));
-      var prefixedScopeImports = prefixScopeImports(scopeValue, folderPattern, scopeKey);
-      scopesPrefixed[prefixedScopeKey] = "/" in scopeValue ? ensureLeadingSlashImportWrapped(prefixedScopeImports, prefixedScopeKey) : prefixedScopeImports;
-    }
-  });
-  return scopesPrefixed;
+var wrapSpecifier = function wrapSpecifier(specifier, into) {
+  if (isOriginRelativeSpecifier(specifier)) {
+    return "".concat(into).concat(specifier.slice(1));
+  }
+
+  if (isBareSpecifier(specifier)) {
+    return "".concat(into).concat(specifier);
+  }
+
+  return specifier;
 };
 
-var prefixScopeImports = function prefixScopeImports(imports, folderPattern, scopeKey) {
-  var importsPrefixed = {};
-  Object.keys(imports).forEach(function (importKey) {
-    var importValue = imports[importKey];
+var isOriginRelativeSpecifier = function isOriginRelativeSpecifier(specifier) {
+  return specifier[0] === "/" && specifier[1] !== "/";
+};
 
-    if (importValue[0] === "/") {
-      var prefixedImportKey = importKey.startsWith(scopeKey) ? "".concat(folderPattern.slice(0, -1)).concat(importKey) : importKey;
-      importsPrefixed[prefixedImportKey] = "".concat(folderPattern).concat(importValue.slice(1));
-    }
-  });
-  return importsPrefixed;
+var isBareSpecifier = function isBareSpecifier(specifier) {
+  // it has a scheme
+  if (/^[a-zA-Z]+:/.test(specifier)) return false; // scheme relative
+
+  if (specifier.slice(0, 2) === "//") return false; // pathname relative
+
+  if (specifier.slice(0, 2) === "./") return false;
+  if (specifier.slice(0, 3) === "../") return false;
+  return true;
 };
@@ -448,0 +467,0 @@

package.json

 {
   "name": "@jsenv/import-map",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "license": "MIT",
@@ -5,0 +5,0 @@ "repository": {

src/wrapImportMap/wrapImportMap.js

@@ -23,78 +23,96 @@ /**
 
-  const folderPattern = `/${folderRelativeName}/`
+  const into = `/${folderRelativeName}/`
   const { imports, scopes } = importMap
-  const importsWrapped = imports ? prefixImports(imports, folderPattern) : {}
-  const scopesWrapped = scopes ? prefixScopes(scopes, folderPattern) : {}
 
-  if (imports && "/" in imports) {
-    scopesWrapped[folderPattern] = {
-      [folderPattern]: folderPattern,
-    }
+  let importsForWrapping
+  let scopesForWrapping
+
+  if (scopes) {
+    scopesForWrapping = {}
+    Object.keys(scopes).forEach((scopeKey) => {
+      const scopeValue = scopes[scopeKey]
+      const scopeKeyPrefixed = wrapSpecifier(scopeKey, into)
+
+      if (scopeKeyPrefixed === scopeKey) {
+        scopesForWrapping[scopeKey] = scopeValue
+      } else {
+        scopesForWrapping[scopeKeyPrefixed] = wrapImports(scopeValue, into)
+      }
+    })
+  } else {
+    scopesForWrapping = {}
   }
 
+  if (imports) {
+    importsForWrapping = wrapImports(imports, into)
+    scopesForWrapping[into] = wrapImports(imports, into)
+  } else {
+    importsForWrapping = {}
+    scopesForWrapping[into] = {}
+  }
+
+  // ensure anything not directly remapped is remapped inside into
+  importsForWrapping[into] = into
+  importsForWrapping["/"] = into
+  // and when already into, you stay inside
+  scopesForWrapping[into]["/"] = "/"
+
   return {
-    imports: importsWrapped,
-    scopes: scopesWrapped,
+    imports: importsForWrapping,
+    scopes: scopesForWrapping,
   }
 }
 
-// this function must make sure it returns imports so that
-// Object.keys(imports).indexOf('/') === Object.keys(imports).length - 1
-// Object.keys(imports).indexOf(folderPattern) === Object.keys(imports).length - 2
-// even if imports already contains '/' or folderPattern
-const ensureLeadingSlashImportWrapped = (imports, folderPattern) => {
-  const wrappedImports = {}
-  Object.keys(imports).forEach((key) => {
-    if (key === "/" || key === folderPattern) return
-    wrappedImports[key] = imports[key]
-  })
-  wrappedImports[folderPattern] = folderPattern
-  wrappedImports["/"] = folderPattern
-  return wrappedImports
-}
+const wrapImports = (imports, into) => {
+  const importsWithKeyWrapped = {}
+  const importsRemaining = {}
 
-const prefixImports = (imports, folderPattern) => {
-  const importsPrefixed = {}
   Object.keys(imports).forEach((importKey) => {
     const importValue = imports[importKey]
+    const importKeyWrapped = wrapSpecifier(importKey, into)
+    const importValueWrapped = wrapSpecifier(importValue, into)
 
-    if (importValue === "/") {
-      importsPrefixed[folderPattern] = folderPattern
+    if (importKeyWrapped === importKey) {
+      importsRemaining[importKey] = importValue
+    } else if (importValueWrapped === importValue) {
+      importsWithKeyWrapped[importKeyWrapped] = importValue
+    } else {
+      importsWithKeyWrapped[importKeyWrapped] = importValueWrapped
+      importsRemaining[importKey] = importValueWrapped
     }
+  })
 
-    if (importValue[0] === "/") {
-      importsPrefixed[importKey] = `${folderPattern}${importValue.slice(1)}`
-    }
-  })
-  return importsPrefixed
+  const importsWrapped = {
+    ...importsWithKeyWrapped,
+    ...importsRemaining,
+  }
+  return importsWrapped
 }
 
-const prefixScopes = (scopes, folderPattern) => {
-  const scopesPrefixed = {}
-  Object.keys(scopes).forEach((scopeKey) => {
-    if (scopeKey[0] === "/") {
-      const scopeValue = scopes[scopeKey]
-      const prefixedScopeKey = `${folderPattern}${scopeKey.slice(1)}`
-      const prefixedScopeImports = prefixScopeImports(scopeValue, folderPattern, scopeKey)
-      scopesPrefixed[prefixedScopeKey] =
-        "/" in scopeValue
-          ? ensureLeadingSlashImportWrapped(prefixedScopeImports, prefixedScopeKey)
-          : prefixedScopeImports
-    }
-  })
-  return scopesPrefixed
+const wrapSpecifier = (specifier, into) => {
+  if (isOriginRelativeSpecifier(specifier)) {
+    return `${into}${specifier.slice(1)}`
+  }
+  if (isBareSpecifier(specifier)) {
+    return `${into}${specifier}`
+  }
+  return specifier
 }
 
-const prefixScopeImports = (imports, folderPattern, scopeKey) => {
-  const importsPrefixed = {}
-  Object.keys(imports).forEach((importKey) => {
-    const importValue = imports[importKey]
-    if (importValue[0] === "/") {
-      const prefixedImportKey = importKey.startsWith(scopeKey)
-        ? `${folderPattern.slice(0, -1)}${importKey}`
-        : importKey
-      importsPrefixed[prefixedImportKey] = `${folderPattern}${importValue.slice(1)}`
-    }
-  })
-  return importsPrefixed
+const isOriginRelativeSpecifier = (specifier) => {
+  return specifier[0] === "/" && specifier[1] !== "/"
 }
+
+const isBareSpecifier = (specifier) => {
+  // it has a scheme
+  if (/^[a-zA-Z]+:/.test(specifier)) return false
+
+  // scheme relative
+  if (specifier.slice(0, 2) === "//") return false
+
+  // pathname relative
+  if (specifier.slice(0, 2) === "./") return false
+  if (specifier.slice(0, 3) === "../") return false
+
+  return true
+}

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

98788

increased by0.15%

Lines of code

687

increased by3.15%

No dependency changes