@jsenv/core 34.3.0 → 35.0.1

package/dist/js/resolveImport.js

@@ -1,504 +0,0 @@
-// duplicated from @jsenv/log to avoid the dependency
-const createDetailedMessage = (message, details = {}) => {
-  let string = `${message}`;
-  Object.keys(details).forEach(key => {
-    const value = details[key];
-    string += `
-    --- ${key} ---
-    ${Array.isArray(value) ? value.join(`
-    `) : value}`;
-  });
-  return string;
-};
-
-const assertImportMap = value => {
-  if (value === null) {
-    throw new TypeError(`an importMap must be an object, got null`);
-  }
-  const type = typeof value;
-  if (type !== "object") {
-    throw new TypeError(`an importMap must be an object, received ${value}`);
-  }
-  if (Array.isArray(value)) {
-    throw new TypeError(`an importMap must be an object, received array ${value}`);
-  }
-};
-
-const hasScheme = string => {
-  return /^[a-zA-Z]{2,}:/.test(string);
-};
-
-const urlToScheme = urlString => {
-  const colonIndex = urlString.indexOf(":");
-  if (colonIndex === -1) return "";
-  return urlString.slice(0, colonIndex);
-};
-
-const urlToPathname = urlString => {
-  return ressourceToPathname(urlToRessource(urlString));
-};
-const urlToRessource = urlString => {
-  const scheme = urlToScheme(urlString);
-  if (scheme === "file") {
-    return urlString.slice("file://".length);
-  }
-  if (scheme === "https" || scheme === "http") {
-    // remove origin
-    const afterProtocol = urlString.slice(scheme.length + "://".length);
-    const pathnameSlashIndex = afterProtocol.indexOf("/", "://".length);
-    return afterProtocol.slice(pathnameSlashIndex);
-  }
-  return urlString.slice(scheme.length + 1);
-};
-const ressourceToPathname = ressource => {
-  const searchSeparatorIndex = ressource.indexOf("?");
-  return searchSeparatorIndex === -1 ? ressource : ressource.slice(0, searchSeparatorIndex);
-};
-
-const urlToOrigin = urlString => {
-  const scheme = urlToScheme(urlString);
-  if (scheme === "file") {
-    return "file://";
-  }
-  if (scheme === "http" || scheme === "https") {
-    const secondProtocolSlashIndex = scheme.length + "://".length;
-    const pathnameSlashIndex = urlString.indexOf("/", secondProtocolSlashIndex);
-    if (pathnameSlashIndex === -1) return urlString;
-    return urlString.slice(0, pathnameSlashIndex);
-  }
-  return urlString.slice(0, scheme.length + 1);
-};
-
-const pathnameToParentPathname = pathname => {
-  const slashLastIndex = pathname.lastIndexOf("/");
-  if (slashLastIndex === -1) {
-    return "/";
-  }
-  return pathname.slice(0, slashLastIndex + 1);
-};
-
-// could be useful: https://url.spec.whatwg.org/#url-miscellaneous
-const resolveUrl = (specifier, baseUrl) => {
-  if (baseUrl) {
-    if (typeof baseUrl !== "string") {
-      throw new TypeError(writeBaseUrlMustBeAString({
-        baseUrl,
-        specifier
-      }));
-    }
-    if (!hasScheme(baseUrl)) {
-      throw new Error(writeBaseUrlMustBeAbsolute({
-        baseUrl,
-        specifier
-      }));
-    }
-  }
-  if (hasScheme(specifier)) {
-    return specifier;
-  }
-  if (!baseUrl) {
-    throw new Error(writeBaseUrlRequired({
-      baseUrl,
-      specifier
-    }));
-  }
-
-  // scheme relative
-  if (specifier.slice(0, 2) === "//") {
-    return `${urlToScheme(baseUrl)}:${specifier}`;
-  }
-
-  // origin relative
-  if (specifier[0] === "/") {
-    return `${urlToOrigin(baseUrl)}${specifier}`;
-  }
-  const baseOrigin = urlToOrigin(baseUrl);
-  const basePathname = urlToPathname(baseUrl);
-  if (specifier === ".") {
-    const baseDirectoryPathname = pathnameToParentPathname(basePathname);
-    return `${baseOrigin}${baseDirectoryPathname}`;
-  }
-
-  // pathname relative inside
-  if (specifier.slice(0, 2) === "./") {
-    const baseDirectoryPathname = pathnameToParentPathname(basePathname);
-    return `${baseOrigin}${baseDirectoryPathname}${specifier.slice(2)}`;
-  }
-
-  // pathname relative outside
-  if (specifier.slice(0, 3) === "../") {
-    let unresolvedPathname = specifier;
-    const importerFolders = basePathname.split("/");
-    importerFolders.pop();
-    while (unresolvedPathname.slice(0, 3) === "../") {
-      unresolvedPathname = unresolvedPathname.slice(3);
-      // when there is no folder left to resolved
-      // we just ignore '../'
-      if (importerFolders.length) {
-        importerFolders.pop();
-      }
-    }
-    const resolvedPathname = `${importerFolders.join("/")}/${unresolvedPathname}`;
-    return `${baseOrigin}${resolvedPathname}`;
-  }
-
-  // bare
-  if (basePathname === "") {
-    return `${baseOrigin}/${specifier}`;
-  }
-  if (basePathname[basePathname.length] === "/") {
-    return `${baseOrigin}${basePathname}${specifier}`;
-  }
-  return `${baseOrigin}${pathnameToParentPathname(basePathname)}${specifier}`;
-};
-const writeBaseUrlMustBeAString = ({
-  baseUrl,
-  specifier
-}) => `baseUrl must be a string.
---- base url ---
-${baseUrl}
---- specifier ---
-${specifier}`;
-const writeBaseUrlMustBeAbsolute = ({
-  baseUrl,
-  specifier
-}) => `baseUrl must be absolute.
---- base url ---
-${baseUrl}
---- specifier ---
-${specifier}`;
-const writeBaseUrlRequired = ({
-  baseUrl,
-  specifier
-}) => `baseUrl required to resolve relative specifier.
---- base url ---
-${baseUrl}
---- specifier ---
-${specifier}`;
-
-const tryUrlResolution = (string, url) => {
-  const result = resolveUrl(string, url);
-  return hasScheme(result) ? result : null;
-};
-
-const resolveSpecifier = (specifier, importer) => {
-  if (specifier === "." || specifier[0] === "/" || specifier.startsWith("./") || specifier.startsWith("../")) {
-    return resolveUrl(specifier, importer);
-  }
-  if (hasScheme(specifier)) {
-    return specifier;
-  }
-  return null;
-};
-
-const applyImportMap = ({
-  importMap,
-  specifier,
-  importer,
-  createBareSpecifierError = ({
-    specifier,
-    importer
-  }) => {
-    return new Error(createDetailedMessage(`Unmapped bare specifier.`, {
-      specifier,
-      importer
-    }));
-  },
-  onImportMapping = () => {}
-}) => {
-  assertImportMap(importMap);
-  if (typeof specifier !== "string") {
-    throw new TypeError(createDetailedMessage("specifier must be a string.", {
-      specifier,
-      importer
-    }));
-  }
-  if (importer) {
-    if (typeof importer !== "string") {
-      throw new TypeError(createDetailedMessage("importer must be a string.", {
-        importer,
-        specifier
-      }));
-    }
-    if (!hasScheme(importer)) {
-      throw new Error(createDetailedMessage(`importer must be an absolute url.`, {
-        importer,
-        specifier
-      }));
-    }
-  }
-  const specifierUrl = resolveSpecifier(specifier, importer);
-  const specifierNormalized = specifierUrl || specifier;
-  const {
-    scopes
-  } = importMap;
-  if (scopes && importer) {
-    const scopeSpecifierMatching = Object.keys(scopes).find(scopeSpecifier => {
-      return scopeSpecifier === importer || specifierIsPrefixOf(scopeSpecifier, importer);
-    });
-    if (scopeSpecifierMatching) {
-      const scopeMappings = scopes[scopeSpecifierMatching];
-      const mappingFromScopes = applyMappings(scopeMappings, specifierNormalized, scopeSpecifierMatching, onImportMapping);
-      if (mappingFromScopes !== null) {
-        return mappingFromScopes;
-      }
-    }
-  }
-  const {
-    imports
-  } = importMap;
-  if (imports) {
-    const mappingFromImports = applyMappings(imports, specifierNormalized, undefined, onImportMapping);
-    if (mappingFromImports !== null) {
-      return mappingFromImports;
-    }
-  }
-  if (specifierUrl) {
-    return specifierUrl;
-  }
-  throw createBareSpecifierError({
-    specifier,
-    importer
-  });
-};
-const applyMappings = (mappings, specifierNormalized, scope, onImportMapping) => {
-  const specifierCandidates = Object.keys(mappings);
-  let i = 0;
-  while (i < specifierCandidates.length) {
-    const specifierCandidate = specifierCandidates[i];
-    i++;
-    if (specifierCandidate === specifierNormalized) {
-      const address = mappings[specifierCandidate];
-      onImportMapping({
-        scope,
-        from: specifierCandidate,
-        to: address,
-        before: specifierNormalized,
-        after: address
-      });
-      return address;
-    }
-    if (specifierIsPrefixOf(specifierCandidate, specifierNormalized)) {
-      const address = mappings[specifierCandidate];
-      const afterSpecifier = specifierNormalized.slice(specifierCandidate.length);
-      const addressFinal = tryUrlResolution(afterSpecifier, address);
-      onImportMapping({
-        scope,
-        from: specifierCandidate,
-        to: address,
-        before: specifierNormalized,
-        after: addressFinal
-      });
-      return addressFinal;
-    }
-  }
-  return null;
-};
-const specifierIsPrefixOf = (specifierHref, href) => {
-  return specifierHref[specifierHref.length - 1] === "/" && href.startsWith(specifierHref);
-};
-
-const sortImports = imports => {
-  const mappingsSorted = {};
-  Object.keys(imports).sort(compareLengthOrLocaleCompare).forEach(name => {
-    mappingsSorted[name] = imports[name];
-  });
-  return mappingsSorted;
-};
-const sortScopes = scopes => {
-  const scopesSorted = {};
-  Object.keys(scopes).sort(compareLengthOrLocaleCompare).forEach(scopeSpecifier => {
-    scopesSorted[scopeSpecifier] = sortImports(scopes[scopeSpecifier]);
-  });
-  return scopesSorted;
-};
-const compareLengthOrLocaleCompare = (a, b) => {
-  return b.length - a.length || a.localeCompare(b);
-};
-
-const normalizeImportMap = (importMap, baseUrl) => {
-  assertImportMap(importMap);
-  if (!isStringOrUrl(baseUrl)) {
-    throw new TypeError(formulateBaseUrlMustBeStringOrUrl({
-      baseUrl
-    }));
-  }
-  const {
-    imports,
-    scopes
-  } = importMap;
-  return {
-    imports: imports ? normalizeMappings(imports, baseUrl) : undefined,
-    scopes: scopes ? normalizeScopes(scopes, baseUrl) : undefined
-  };
-};
-const isStringOrUrl = value => {
-  if (typeof value === "string") {
-    return true;
-  }
-  if (typeof URL === "function" && value instanceof URL) {
-    return true;
-  }
-  return false;
-};
-const normalizeMappings = (mappings, baseUrl) => {
-  const mappingsNormalized = {};
-  Object.keys(mappings).forEach(specifier => {
-    const address = mappings[specifier];
-    if (typeof address !== "string") {
-      console.warn(formulateAddressMustBeAString({
-        address,
-        specifier
-      }));
-      return;
-    }
-    const specifierResolved = resolveSpecifier(specifier, baseUrl) || specifier;
-    const addressUrl = tryUrlResolution(address, baseUrl);
-    if (addressUrl === null) {
-      console.warn(formulateAdressResolutionFailed({
-        address,
-        baseUrl,
-        specifier
-      }));
-      return;
-    }
-    if (specifier.endsWith("/") && !addressUrl.endsWith("/")) {
-      console.warn(formulateAddressUrlRequiresTrailingSlash({
-        addressUrl,
-        address,
-        specifier
-      }));
-      return;
-    }
-    mappingsNormalized[specifierResolved] = addressUrl;
-  });
-  return sortImports(mappingsNormalized);
-};
-const normalizeScopes = (scopes, baseUrl) => {
-  const scopesNormalized = {};
-  Object.keys(scopes).forEach(scopeSpecifier => {
-    const scopeMappings = scopes[scopeSpecifier];
-    const scopeUrl = tryUrlResolution(scopeSpecifier, baseUrl);
-    if (scopeUrl === null) {
-      console.warn(formulateScopeResolutionFailed({
-        scope: scopeSpecifier,
-        baseUrl
-      }));
-      return;
-    }
-    const scopeValueNormalized = normalizeMappings(scopeMappings, baseUrl);
-    scopesNormalized[scopeUrl] = scopeValueNormalized;
-  });
-  return sortScopes(scopesNormalized);
-};
-const formulateBaseUrlMustBeStringOrUrl = ({
-  baseUrl
-}) => `baseUrl must be a string or an url.
---- base url ---
-${baseUrl}`;
-const formulateAddressMustBeAString = ({
-  specifier,
-  address
-}) => `Address must be a string.
---- address ---
-${address}
---- specifier ---
-${specifier}`;
-const formulateAdressResolutionFailed = ({
-  address,
-  baseUrl,
-  specifier
-}) => `Address url resolution failed.
---- address ---
-${address}
---- base url ---
-${baseUrl}
---- specifier ---
-${specifier}`;
-const formulateAddressUrlRequiresTrailingSlash = ({
-  addressURL,
-  address,
-  specifier
-}) => `Address must end with /.
---- address url ---
-${addressURL}
---- address ---
-${address}
---- specifier ---
-${specifier}`;
-const formulateScopeResolutionFailed = ({
-  scope,
-  baseUrl
-}) => `Scope url resolution failed.
---- scope ---
-${scope}
---- base url ---
-${baseUrl}`;
-
-const pathnameToExtension = pathname => {
-  const slashLastIndex = pathname.lastIndexOf("/");
-  if (slashLastIndex !== -1) {
-    pathname = pathname.slice(slashLastIndex + 1);
-  }
-  const dotLastIndex = pathname.lastIndexOf(".");
-  if (dotLastIndex === -1) return "";
-  // if (dotLastIndex === pathname.length - 1) return ""
-  return pathname.slice(dotLastIndex);
-};
-
-const resolveImport = ({
-  specifier,
-  importer,
-  importMap,
-  defaultExtension = false,
-  createBareSpecifierError,
-  onImportMapping = () => {}
-}) => {
-  let url;
-  if (importMap) {
-    url = applyImportMap({
-      importMap,
-      specifier,
-      importer,
-      createBareSpecifierError,
-      onImportMapping
-    });
-  } else {
-    url = resolveUrl(specifier, importer);
-  }
-  if (defaultExtension) {
-    url = applyDefaultExtension({
-      url,
-      importer,
-      defaultExtension
-    });
-  }
-  return url;
-};
-const applyDefaultExtension = ({
-  url,
-  importer,
-  defaultExtension
-}) => {
-  if (urlToPathname(url).endsWith("/")) {
-    return url;
-  }
-  if (typeof defaultExtension === "string") {
-    const extension = pathnameToExtension(url);
-    if (extension === "") {
-      return `${url}${defaultExtension}`;
-    }
-    return url;
-  }
-  if (defaultExtension === true) {
-    const extension = pathnameToExtension(url);
-    if (extension === "" && importer) {
-      const importerPathname = urlToPathname(importer);
-      const importerExtension = pathnameToExtension(importerPathname);
-      return `${url}${importerExtension}`;
-    }
-  }
-  return url;
-};
-
-export { assertImportMap, normalizeImportMap, resolveImport, resolveUrl };