@jsenv/urls 2.0.0 → 2.1.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@jsenv/urls",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jsenv/jsenv-core",
-    "directory": "packages/urls"
+    "url": "https://github.com/jsenv/core",
+    "directory": "packages/independent/urls"
   },
   "publishConfig": {
     "access": "public"

package/src/caller_position.js

@@ -1,15 +1,15 @@
-import { isFileSystemPath } from "./is_filesystem_path.js"
-import { fileSystemPathToUrl } from "./filesystem_path_to_url.js"
+import { isFileSystemPath } from "./is_filesystem_path.js";
+import { fileSystemPathToUrl } from "./filesystem_path_to_url.js";
 
 export const getCallerPosition = () => {
-  const { prepareStackTrace } = Error
+  const { prepareStackTrace } = Error;
   Error.prepareStackTrace = (error, stack) => {
-    Error.prepareStackTrace = prepareStackTrace
-    return stack
-  }
-  const { stack } = new Error()
-  const callerCallsite = stack[2]
-  const fileName = callerCallsite.getFileName()
+    Error.prepareStackTrace = prepareStackTrace;
+    return stack;
+  };
+  const { stack } = new Error();
+  const callerCallsite = stack[2];
+  const fileName = callerCallsite.getFileName();
   return {
     url:
       fileName && isFileSystemPath(fileName)
@@ -17,5 +17,5 @@ export const getCallerPosition = () => {
         : fileName,
     line: callerCallsite.getLineNumber(),
     column: callerCallsite.getColumnNumber(),
-  }
-}
+  };
+};

package/src/common_pathname.js

@@ -1,36 +1,36 @@
 export const getCommonPathname = (pathname, otherPathname) => {
   if (pathname === otherPathname) {
-    return pathname
+    return pathname;
   }
-  let commonPart = ""
-  let commonPathname = ""
-  let i = 0
-  const length = pathname.length
-  const otherLength = otherPathname.length
+  let commonPart = "";
+  let commonPathname = "";
+  let i = 0;
+  const length = pathname.length;
+  const otherLength = otherPathname.length;
   while (i < length) {
-    const char = pathname.charAt(i)
-    const otherChar = otherPathname.charAt(i)
-    i++
+    const char = pathname.charAt(i);
+    const otherChar = otherPathname.charAt(i);
+    i++;
     if (char === otherChar) {
       if (char === "/") {
-        commonPart += "/"
-        commonPathname += commonPart
-        commonPart = ""
+        commonPart += "/";
+        commonPathname += commonPart;
+        commonPart = "";
       } else {
-        commonPart += char
+        commonPart += char;
       }
     } else {
       if (char === "/" && i - 1 === otherLength) {
-        commonPart += "/"
-        commonPathname += commonPart
+        commonPart += "/";
+        commonPathname += commonPart;
       }
-      return commonPathname
+      return commonPathname;
     }
   }
   if (length === otherLength) {
-    commonPathname += commonPart
+    commonPathname += commonPart;
   } else if (otherPathname.charAt(i) === "/") {
-    commonPathname += commonPart
+    commonPathname += commonPart;
   }
-  return commonPathname
-}
+  return commonPathname;
+};

package/src/data_url.js

@@ -7,44 +7,44 @@
 
 export const DATA_URL = {
   parse: (string) => {
-    const afterDataProtocol = string.slice("data:".length)
-    const commaIndex = afterDataProtocol.indexOf(",")
-    const beforeComma = afterDataProtocol.slice(0, commaIndex)
+    const afterDataProtocol = string.slice("data:".length);
+    const commaIndex = afterDataProtocol.indexOf(",");
+    const beforeComma = afterDataProtocol.slice(0, commaIndex);
 
-    let contentType
-    let base64Flag
+    let contentType;
+    let base64Flag;
     if (beforeComma.endsWith(`;base64`)) {
-      contentType = beforeComma.slice(0, -`;base64`.length)
-      base64Flag = true
+      contentType = beforeComma.slice(0, -`;base64`.length);
+      base64Flag = true;
     } else {
-      contentType = beforeComma
-      base64Flag = false
+      contentType = beforeComma;
+      base64Flag = false;
     }
 
     contentType =
-      contentType === "" ? "text/plain;charset=US-ASCII" : contentType
-    const afterComma = afterDataProtocol.slice(commaIndex + 1)
+      contentType === "" ? "text/plain;charset=US-ASCII" : contentType;
+    const afterComma = afterDataProtocol.slice(commaIndex + 1);
     return {
       contentType,
       base64Flag,
       data: afterComma,
-    }
+    };
   },
 
   stringify: ({ contentType, base64Flag = true, data }) => {
     if (!contentType || contentType === "text/plain;charset=US-ASCII") {
       // can be a buffer or a string, hence check on data.length instead of !data or data === ''
       if (data.length === 0) {
-        return `data:,`
+        return `data:,`;
       }
       if (base64Flag) {
-        return `data:;base64,${data}`
+        return `data:;base64,${data}`;
       }
-      return `data:,${data}`
+      return `data:,${data}`;
     }
     if (base64Flag) {
-      return `data:${contentType};base64,${data}`
+      return `data:${contentType};base64,${data}`;
     }
-    return `data:${contentType},${data}`
+    return `data:${contentType},${data}`;
   },
-}
+};

package/src/ensure_url_trailing_slash.js

@@ -1,3 +1,3 @@
 export const ensureUrlTrailingSlash = (url) => {
-  return url.endsWith("/") ? url : `${url}/`
-}
+  return url.endsWith("/") ? url : `${url}/`;
+};

package/src/filesystem_path_to_url.js

@@ -1,10 +1,10 @@
-import { pathToFileURL } from "node:url"
+import { pathToFileURL } from "node:url";
 
-import { isFileSystemPath } from "./is_filesystem_path.js"
+import { isFileSystemPath } from "./is_filesystem_path.js";
 
 export const fileSystemPathToUrl = (value) => {
   if (!isFileSystemPath(value)) {
-    throw new Error(`value must be a filesystem path, got ${value}`)
+    throw new Error(`value must be a filesystem path, got ${value}`);
   }
-  return String(pathToFileURL(value))
-}
+  return String(pathToFileURL(value));
+};

package/src/inline_content_url_generator.js

@@ -1,18 +1,29 @@
-import { urlToFilename } from "./url_to_filename.js"
+import { urlToFilename } from "./url_to_filename.js";
 
 export const generateInlineContentUrl = ({
   url,
   extension,
+  basename,
   line,
   column,
   lineEnd,
   columnEnd,
 }) => {
-  const generatedName = `L${line}C${column}-L${lineEnd}C${columnEnd}`
-  const filenameRaw = urlToFilename(url)
-  const filename = `${filenameRaw}@${generatedName}${extension}`
+  let generatedName = "";
+  if (basename !== undefined) {
+    generatedName += basename;
+  }
+  if (line !== undefined && column !== undefined) {
+    generatedName = `L${line}C${column}`;
+    if (lineEnd !== undefined && columnEnd !== undefined) {
+      generatedName += `-L${lineEnd}C${columnEnd}`;
+    }
+  }
+
+  const filenameRaw = urlToFilename(url);
+  const filename = `${filenameRaw}@${generatedName}${extension}`;
   // ideally we should keep query params from url
   // maybe we could use a custom scheme like "inline:"
-  const inlineContentUrl = new URL(filename, url).href
-  return inlineContentUrl
-}
+  const inlineContentUrl = new URL(filename, url).href;
+  return inlineContentUrl;
+};

package/src/is_filesystem_path.js

@@ -2,20 +2,20 @@ export const isFileSystemPath = (value) => {
   if (typeof value !== "string") {
     throw new TypeError(
       `isFileSystemPath first arg must be a string, got ${value}`,
-    )
+    );
   }
   if (value[0] === "/") {
-    return true
+    return true;
   }
-  return startsWithWindowsDriveLetter(value)
-}
+  return startsWithWindowsDriveLetter(value);
+};
 
 const startsWithWindowsDriveLetter = (string) => {
-  const firstChar = string[0]
-  if (!/[a-zA-Z]/.test(firstChar)) return false
+  const firstChar = string[0];
+  if (!/[a-zA-Z]/.test(firstChar)) return false;
 
-  const secondChar = string[1]
-  if (secondChar !== ":") return false
+  const secondChar = string[1];
+  if (secondChar !== ":") return false;
 
-  return true
-}
+  return true;
+};

package/src/main.js

@@ -1,41 +1,44 @@
-export { DATA_URL } from "./data_url.js"
-export { generateInlineContentUrl } from "./inline_content_url_generator.js"
+export { DATA_URL } from "./data_url.js";
+export { generateInlineContentUrl } from "./inline_content_url_generator.js";
 export {
   stringifyUrlTrace,
   stringifyUrlSite,
   showSourceLocation,
-} from "./url_trace.js"
+} from "./url_trace.js";
 export {
   asUrlWithoutSearch,
   isValidUrl,
   normalizeUrl,
   injectQueryParamsIntoSpecifier,
   injectQueryParams,
+  injectQueryParamWithoutEncoding,
+  injectQueryParamIntoSpecifierWithoutEncoding,
+  renderUrlOrRelativeUrlFilename,
   setUrlExtension,
   setUrlFilename,
   ensurePathnameTrailingSlash,
   asUrlUntilPathname,
-} from "./url_utils.js"
+} from "./url_utils.js";
 export {
   startsWithWindowsDriveLetter,
   windowsFilePathToUrl,
   replaceBackSlashesWithSlashes,
-} from "./windows_file_path_utils.js"
-export { getCallerPosition } from "./caller_position.js"
+} from "./windows_file_path_utils.js";
+export { getCallerPosition } from "./caller_position.js";
 
-export { fileSystemPathToUrl } from "./filesystem_path_to_url.js"
-export { isFileSystemPath } from "./is_filesystem_path.js"
-export { resolveDirectoryUrl } from "./resolve_directory_url.js"
-export { moveUrl } from "./move_url.js"
-export { resolveUrl } from "./resolve_url.js"
-export { urlIsInsideOf } from "./url_is_inside_of.js"
-export { urlToBasename } from "./url_to_basename.js"
-export { urlToExtension } from "./url_to_extension.js"
-export { urlToFilename } from "./url_to_filename.js"
-export { urlToFileSystemPath } from "./url_to_filesystem_path.js"
-export { urlToOrigin } from "./url_to_origin.js"
-export { urlToParentUrl } from "./url_to_parent_url.js"
-export { urlToPathname } from "./url_to_pathname.js"
-export { urlToRelativeUrl } from "./url_to_relative_url.js"
-export { urlToResource } from "./url_to_resource.js"
-export { urlToScheme } from "./url_to_scheme.js"
+export { fileSystemPathToUrl } from "./filesystem_path_to_url.js";
+export { isFileSystemPath } from "./is_filesystem_path.js";
+export { resolveDirectoryUrl } from "./resolve_directory_url.js";
+export { moveUrl } from "./move_url.js";
+export { resolveUrl } from "./resolve_url.js";
+export { urlIsInsideOf } from "./url_is_inside_of.js";
+export { urlToBasename } from "./url_to_basename.js";
+export { urlToExtension } from "./url_to_extension.js";
+export { urlToFilename } from "./url_to_filename.js";
+export { urlToFileSystemPath } from "./url_to_filesystem_path.js";
+export { urlToOrigin } from "./url_to_origin.js";
+export { urlToParentUrl } from "./url_to_parent_url.js";
+export { urlToPathname } from "./url_to_pathname.js";
+export { urlToRelativeUrl } from "./url_to_relative_url.js";
+export { urlToResource } from "./url_to_resource.js";
+export { urlToScheme } from "./url_to_scheme.js";

package/src/move_url.js

@@ -1,14 +1,14 @@
-import { urlToRelativeUrl } from "./url_to_relative_url.js"
+import { urlToRelativeUrl } from "./url_to_relative_url.js";
 
 export const moveUrl = ({ url, from, to, preferRelative }) => {
-  let relativeUrl = urlToRelativeUrl(url, from)
+  let relativeUrl = urlToRelativeUrl(url, from);
   if (relativeUrl.slice(0, 2) === "//") {
     // restore the protocol
-    relativeUrl = new URL(relativeUrl, url).href
+    relativeUrl = new URL(relativeUrl, url).href;
   }
-  const absoluteUrl = new URL(relativeUrl, to).href
+  const absoluteUrl = new URL(relativeUrl, to).href;
   if (preferRelative) {
-    return urlToRelativeUrl(absoluteUrl, to)
+    return urlToRelativeUrl(absoluteUrl, to);
   }
-  return absoluteUrl
-}
+  return absoluteUrl;
+};

package/src/resolve_directory_url.js

@@ -1,7 +1,7 @@
-import { ensurePathnameTrailingSlash } from "./url_utils.js"
-import { resolveUrl } from "./resolve_url.js"
+import { ensurePathnameTrailingSlash } from "./url_utils.js";
+import { resolveUrl } from "./resolve_url.js";
 
 export const resolveDirectoryUrl = (specifier, baseUrl) => {
-  const url = resolveUrl(specifier, baseUrl)
-  return ensurePathnameTrailingSlash(url)
-}
+  const url = resolveUrl(specifier, baseUrl);
+  return ensurePathnameTrailingSlash(url);
+};

package/src/resolve_url.js

@@ -1,6 +1,6 @@
 export const resolveUrl = (specifier, baseUrl) => {
   if (typeof baseUrl === "undefined") {
-    throw new TypeError(`baseUrl missing to resolve ${specifier}`)
+    throw new TypeError(`baseUrl missing to resolve ${specifier}`);
   }
-  return String(new URL(specifier, baseUrl))
-}
+  return String(new URL(specifier, baseUrl));
+};

package/src/url_is_inside_of.js

@@ -1,17 +1,17 @@
 export const urlIsInsideOf = (url, otherUrl) => {
-  const urlObject = new URL(url)
-  const otherUrlObject = new URL(otherUrl)
+  const urlObject = new URL(url);
+  const otherUrlObject = new URL(otherUrl);
 
   if (urlObject.origin !== otherUrlObject.origin) {
-    return false
+    return false;
   }
 
-  const urlPathname = urlObject.pathname
-  const otherUrlPathname = otherUrlObject.pathname
+  const urlPathname = urlObject.pathname;
+  const otherUrlPathname = otherUrlObject.pathname;
   if (urlPathname === otherUrlPathname) {
-    return false
+    return false;
   }
 
-  const isInside = urlPathname.startsWith(otherUrlPathname)
-  return isInside
-}
+  const isInside = urlPathname.startsWith(otherUrlPathname);
+  return isInside;
+};

package/src/url_to_basename.js

@@ -1,9 +1,9 @@
-import { urlToFilename } from "./url_to_filename.js"
+import { urlToFilename } from "./url_to_filename.js";
 
 export const urlToBasename = (url) => {
-  const filename = urlToFilename(url)
-  const dotLastIndex = filename.lastIndexOf(".")
+  const filename = urlToFilename(url);
+  const dotLastIndex = filename.lastIndexOf(".");
   const basename =
-    dotLastIndex === -1 ? filename : filename.slice(0, dotLastIndex)
-  return basename
-}
+    dotLastIndex === -1 ? filename : filename.slice(0, dotLastIndex);
+  return basename;
+};

package/src/url_to_extension.js

@@ -1,19 +1,19 @@
-import { urlToPathname } from "./url_to_pathname.js"
+import { urlToPathname } from "./url_to_pathname.js";
 
 export const urlToExtension = (url) => {
-  const pathname = urlToPathname(url)
-  return pathnameToExtension(pathname)
-}
+  const pathname = urlToPathname(url);
+  return pathnameToExtension(pathname);
+};
 
 const pathnameToExtension = (pathname) => {
-  const slashLastIndex = pathname.lastIndexOf("/")
+  const slashLastIndex = pathname.lastIndexOf("/");
   if (slashLastIndex !== -1) {
-    pathname = pathname.slice(slashLastIndex + 1)
+    pathname = pathname.slice(slashLastIndex + 1);
   }
 
-  const dotLastIndex = pathname.lastIndexOf(".")
-  if (dotLastIndex === -1) return ""
+  const dotLastIndex = pathname.lastIndexOf(".");
+  if (dotLastIndex === -1) return "";
   // if (dotLastIndex === pathname.length - 1) return ""
-  const extension = pathname.slice(dotLastIndex)
-  return extension
-}
+  const extension = pathname.slice(dotLastIndex);
+  return extension;
+};

package/src/url_to_filename.js

@@ -1,14 +1,14 @@
-import { urlToPathname } from "./url_to_pathname.js"
+import { urlToPathname } from "./url_to_pathname.js";
 
 export const urlToFilename = (url) => {
-  const pathname = urlToPathname(url)
+  const pathname = urlToPathname(url);
   const pathnameBeforeLastSlash = pathname.endsWith("/")
     ? pathname.slice(0, -1)
-    : pathname
-  const slashLastIndex = pathnameBeforeLastSlash.lastIndexOf("/")
+    : pathname;
+  const slashLastIndex = pathnameBeforeLastSlash.lastIndexOf("/");
   const filename =
     slashLastIndex === -1
       ? pathnameBeforeLastSlash
-      : pathnameBeforeLastSlash.slice(slashLastIndex + 1)
-  return filename
-}
+      : pathnameBeforeLastSlash.slice(slashLastIndex + 1);
+  return filename;
+};

package/src/url_to_filesystem_path.js

@@ -1,12 +1,12 @@
-import { fileURLToPath } from "node:url"
+import { fileURLToPath } from "node:url";
 
 export const urlToFileSystemPath = (url) => {
-  let urlString = String(url)
+  let urlString = String(url);
   if (urlString[urlString.length - 1] === "/") {
     // remove trailing / so that nodejs path becomes predictable otherwise it logs
     // the trailing slash on linux but does not on windows
-    urlString = urlString.slice(0, -1)
+    urlString = urlString.slice(0, -1);
   }
-  const fileSystemPath = fileURLToPath(urlString)
-  return fileSystemPath
-}
+  const fileSystemPath = fileURLToPath(urlString);
+  return fileSystemPath;
+};

package/src/url_to_origin.js

@@ -1,7 +1,7 @@
 export const urlToOrigin = (url) => {
-  const urlString = String(url)
+  const urlString = String(url);
   if (urlString.startsWith("file://")) {
-    return `file://`
+    return `file://`;
   }
-  return new URL(urlString).origin
-}
+  return new URL(urlString).origin;
+};

package/src/url_to_parent_url.js

@@ -1,28 +1,31 @@
-import { urlToOrigin } from "./url_to_origin.js"
-import { urlToResource } from "./url_to_resource.js"
+import { urlToOrigin } from "./url_to_origin.js";
+import { urlToResource } from "./url_to_resource.js";
 
 export const urlToParentUrl = (url) => {
-  const resource = urlToResource(url)
-  const slashLastIndex = resource.lastIndexOf("/")
+  const resource = urlToResource(url);
+  const slashLastIndex = resource.lastIndexOf("/");
   if (slashLastIndex === -1) {
-    const urlAsString = String(url)
-    return urlAsString
+    const urlAsString = String(url);
+    return urlAsString;
   }
 
-  const lastCharacterIndex = resource.length - 1
+  const lastCharacterIndex = resource.length - 1;
   if (slashLastIndex === lastCharacterIndex) {
-    const slashPreviousIndex = resource.lastIndexOf("/", lastCharacterIndex - 1)
+    const slashPreviousIndex = resource.lastIndexOf(
+      "/",
+      lastCharacterIndex - 1,
+    );
     if (slashPreviousIndex === -1) {
-      const urlAsString = String(url)
-      return urlAsString
+      const urlAsString = String(url);
+      return urlAsString;
     }
 
-    const origin = urlToOrigin(url)
-    const parentUrl = `${origin}${resource.slice(0, slashPreviousIndex + 1)}`
-    return parentUrl
+    const origin = urlToOrigin(url);
+    const parentUrl = `${origin}${resource.slice(0, slashPreviousIndex + 1)}`;
+    return parentUrl;
   }
 
-  const origin = urlToOrigin(url)
-  const parentUrl = `${origin}${resource.slice(0, slashLastIndex + 1)}`
-  return parentUrl
-}
+  const origin = urlToOrigin(url);
+  const parentUrl = `${origin}${resource.slice(0, slashLastIndex + 1)}`;
+  return parentUrl;
+};

package/src/url_to_pathname.js

@@ -1,19 +1,19 @@
-import { urlToResource } from "./url_to_resource.js"
+import { urlToResource } from "./url_to_resource.js";
 
 export const urlToPathname = (url) => {
-  const resource = urlToResource(url)
-  const pathname = resourceToPathname(resource)
-  return pathname
-}
+  const resource = urlToResource(url);
+  const pathname = resourceToPathname(resource);
+  return pathname;
+};
 
 const resourceToPathname = (resource) => {
-  const searchSeparatorIndex = resource.indexOf("?")
+  const searchSeparatorIndex = resource.indexOf("?");
   if (searchSeparatorIndex > -1) {
-    return resource.slice(0, searchSeparatorIndex)
+    return resource.slice(0, searchSeparatorIndex);
   }
-  const hashIndex = resource.indexOf("#")
+  const hashIndex = resource.indexOf("#");
   if (hashIndex > -1) {
-    return resource.slice(0, hashIndex)
+    return resource.slice(0, hashIndex);
   }
-  return resource
-}
+  return resource;
+};

package/src/url_to_relative_url.js

@@ -1,12 +1,12 @@
-import { getCommonPathname } from "./common_pathname.js"
+import { getCommonPathname } from "./common_pathname.js";
 
 export const urlToRelativeUrl = (url, baseUrl) => {
-  const urlObject = new URL(url)
-  const baseUrlObject = new URL(baseUrl)
+  const urlObject = new URL(url);
+  const baseUrlObject = new URL(baseUrl);
 
   if (urlObject.protocol !== baseUrlObject.protocol) {
-    const urlAsString = String(url)
-    return urlAsString
+    const urlAsString = String(url);
+    return urlAsString;
   }
 
   if (
@@ -14,43 +14,43 @@ export const urlToRelativeUrl = (url, baseUrl) => {
     urlObject.password !== baseUrlObject.password ||
     urlObject.host !== baseUrlObject.host
   ) {
-    const afterUrlScheme = String(url).slice(urlObject.protocol.length)
-    return afterUrlScheme
+    const afterUrlScheme = String(url).slice(urlObject.protocol.length);
+    return afterUrlScheme;
   }
 
-  const { pathname, hash, search } = urlObject
+  const { pathname, hash, search } = urlObject;
   if (pathname === "/") {
-    const baseUrlResourceWithoutLeadingSlash = baseUrlObject.pathname.slice(1)
-    return baseUrlResourceWithoutLeadingSlash
+    const baseUrlResourceWithoutLeadingSlash = baseUrlObject.pathname.slice(1);
+    return baseUrlResourceWithoutLeadingSlash;
   }
 
-  const basePathname = baseUrlObject.pathname
-  const commonPathname = getCommonPathname(pathname, basePathname)
+  const basePathname = baseUrlObject.pathname;
+  const commonPathname = getCommonPathname(pathname, basePathname);
   if (!commonPathname) {
-    const urlAsString = String(url)
-    return urlAsString
+    const urlAsString = String(url);
+    return urlAsString;
   }
-  const specificPathname = pathname.slice(commonPathname.length)
-  const baseSpecificPathname = basePathname.slice(commonPathname.length)
+  const specificPathname = pathname.slice(commonPathname.length);
+  const baseSpecificPathname = basePathname.slice(commonPathname.length);
   if (baseSpecificPathname.includes("/")) {
     const baseSpecificParentPathname =
-      pathnameToParentPathname(baseSpecificPathname)
+      pathnameToParentPathname(baseSpecificPathname);
     const relativeDirectoriesNotation = baseSpecificParentPathname.replace(
       /.*?\//g,
       "../",
-    )
-    const relativeUrl = `${relativeDirectoriesNotation}${specificPathname}${search}${hash}`
-    return relativeUrl
+    );
+    const relativeUrl = `${relativeDirectoriesNotation}${specificPathname}${search}${hash}`;
+    return relativeUrl;
   }
 
-  const relativeUrl = `${specificPathname}${search}${hash}`
-  return relativeUrl
-}
+  const relativeUrl = `${specificPathname}${search}${hash}`;
+  return relativeUrl;
+};
 
 const pathnameToParentPathname = (pathname) => {
-  const slashLastIndex = pathname.lastIndexOf("/")
+  const slashLastIndex = pathname.lastIndexOf("/");
   if (slashLastIndex === -1) {
-    return "/"
+    return "/";
   }
-  return pathname.slice(0, slashLastIndex + 1)
-}
+  return pathname.slice(0, slashLastIndex + 1);
+};

package/src/url_to_resource.js

@@ -1,21 +1,21 @@
-import { urlToScheme } from "./url_to_scheme.js"
+import { urlToScheme } from "./url_to_scheme.js";
 
 export const urlToResource = (url) => {
-  const scheme = urlToScheme(url)
+  const scheme = urlToScheme(url);
 
   if (scheme === "file") {
-    const urlAsStringWithoutFileProtocol = String(url).slice("file://".length)
-    return urlAsStringWithoutFileProtocol
+    const urlAsStringWithoutFileProtocol = String(url).slice("file://".length);
+    return urlAsStringWithoutFileProtocol;
   }
 
   if (scheme === "https" || scheme === "http") {
     // remove origin
-    const afterProtocol = String(url).slice(scheme.length + "://".length)
-    const pathnameSlashIndex = afterProtocol.indexOf("/", "://".length)
-    const urlAsStringWithoutOrigin = afterProtocol.slice(pathnameSlashIndex)
-    return urlAsStringWithoutOrigin
+    const afterProtocol = String(url).slice(scheme.length + "://".length);
+    const pathnameSlashIndex = afterProtocol.indexOf("/", "://".length);
+    const urlAsStringWithoutOrigin = afterProtocol.slice(pathnameSlashIndex);
+    return urlAsStringWithoutOrigin;
   }
 
-  const urlAsStringWithoutProtocol = String(url).slice(scheme.length + 1)
-  return urlAsStringWithoutProtocol
-}
+  const urlAsStringWithoutProtocol = String(url).slice(scheme.length + 1);
+  return urlAsStringWithoutProtocol;
+};

package/src/url_to_scheme.js

@@ -1,10 +1,10 @@
 export const urlToScheme = (url) => {
-  const urlString = String(url)
-  const colonIndex = urlString.indexOf(":")
+  const urlString = String(url);
+  const colonIndex = urlString.indexOf(":");
   if (colonIndex === -1) {
-    return ""
+    return "";
   }
 
-  const scheme = urlString.slice(0, colonIndex)
-  return scheme
-}
+  const scheme = urlString.slice(0, colonIndex);
+  return scheme;
+};

package/src/url_trace.js

@@ -4,11 +4,11 @@
 // https://github.com/babel/babel/blob/eea156b2cb8deecfcf82d52aa1b71ba4995c7d68/packages/babel-code-frame/src/index.js#L1
 
 export const stringifyUrlTrace = (trace) => {
-  let string = ""
+  let string = "";
   trace.forEach(({ type, url, line, column, source }, index) => {
     if (index === 0) {
-      string += stringifyUrlSite({ url, line, column, source })
-      return
+      string += stringifyUrlSite({ url, line, column, source });
+      return;
     }
 
     if (type === "import") {
@@ -16,19 +16,19 @@ export const stringifyUrlTrace = (trace) => {
         url,
         line,
         column,
-      })}`
-      return
+      })}`;
+      return;
     }
 
     string += `\n  referenced by ${stringifyUrlSite({
       url,
       line,
       column,
-    })}`
-  }, "")
+    })}`;
+  }, "");
 
-  return string
-}
+  return string;
+};
 
 export const stringifyUrlSite = (
   { url, line, column, content },
@@ -39,17 +39,17 @@ export const stringifyUrlSite = (
     color,
   } = {},
 ) => {
-  let string = url
+  let string = url;
 
   if (typeof line === "number") {
-    string += `:${line}`
+    string += `:${line}`;
     if (typeof column === "number") {
-      string += `:${column}`
+      string += `:${column}`;
     }
   }
 
   if (!showCodeFrame || typeof line !== "number" || !content) {
-    return string
+    return string;
   }
 
   const sourceLoc = showSourceLocation({
@@ -59,11 +59,11 @@ export const stringifyUrlSite = (
     numberOfSurroundingLinesToShow,
     lineMaxLength,
     color,
-  })
+  });
 
   return `${string}
-${sourceLoc}`
-}
+${sourceLoc}`;
+};
 
 export const showSourceLocation = ({
   content,
@@ -72,125 +72,125 @@ export const showSourceLocation = ({
   numberOfSurroundingLinesToShow = 1,
   lineMaxLength = 120,
 } = {}) => {
-  let mark = (string) => string
-  let aside = (string) => string
+  let mark = (string) => string;
+  let aside = (string) => string;
   // if (color) {
   //   mark = (string) => ANSI.color(string, ANSI.RED)
   //   aside = (string) => ANSI.color(string, ANSI.GREY)
   // }
 
-  const lines = content.split(/\r?\n/)
-  if (line === 0) line = 1
+  const lines = content.split(/\r?\n/);
+  if (line === 0) line = 1;
   let lineRange = {
     start: line - 1,
     end: line,
-  }
-  lineRange = moveLineRangeUp(lineRange, numberOfSurroundingLinesToShow)
-  lineRange = moveLineRangeDown(lineRange, numberOfSurroundingLinesToShow)
-  lineRange = lineRangeWithinLines(lineRange, lines)
-  const linesToShow = lines.slice(lineRange.start, lineRange.end)
-  const endLineNumber = lineRange.end
-  const lineNumberMaxWidth = String(endLineNumber).length
+  };
+  lineRange = moveLineRangeUp(lineRange, numberOfSurroundingLinesToShow);
+  lineRange = moveLineRangeDown(lineRange, numberOfSurroundingLinesToShow);
+  lineRange = lineRangeWithinLines(lineRange, lines);
+  const linesToShow = lines.slice(lineRange.start, lineRange.end);
+  const endLineNumber = lineRange.end;
+  const lineNumberMaxWidth = String(endLineNumber).length;
 
-  if (column === 0) column = 1
+  if (column === 0) column = 1;
 
-  const columnRange = {}
+  const columnRange = {};
   if (column === undefined) {
-    columnRange.start = 0
-    columnRange.end = lineMaxLength
+    columnRange.start = 0;
+    columnRange.end = lineMaxLength;
   } else if (column > lineMaxLength) {
-    columnRange.start = column - Math.floor(lineMaxLength / 2)
-    columnRange.end = column + Math.ceil(lineMaxLength / 2)
+    columnRange.start = column - Math.floor(lineMaxLength / 2);
+    columnRange.end = column + Math.ceil(lineMaxLength / 2);
   } else {
-    columnRange.start = 0
-    columnRange.end = lineMaxLength
+    columnRange.start = 0;
+    columnRange.end = lineMaxLength;
   }
 
   return linesToShow.map((lineSource, index) => {
-    const lineNumber = lineRange.start + index + 1
-    const isMainLine = lineNumber === line
-    const lineSourceTruncated = applyColumnRange(columnRange, lineSource)
-    const lineNumberWidth = String(lineNumber).length
+    const lineNumber = lineRange.start + index + 1;
+    const isMainLine = lineNumber === line;
+    const lineSourceTruncated = applyColumnRange(columnRange, lineSource);
+    const lineNumberWidth = String(lineNumber).length;
     // ensure if line moves from 7,8,9 to 10 the display is still great
     const lineNumberRightSpacing = " ".repeat(
       lineNumberMaxWidth - lineNumberWidth,
-    )
-    const asideSource = `${lineNumber}${lineNumberRightSpacing} |`
-    const lineFormatted = `${aside(asideSource)} ${lineSourceTruncated}`
+    );
+    const asideSource = `${lineNumber}${lineNumberRightSpacing} |`;
+    const lineFormatted = `${aside(asideSource)} ${lineSourceTruncated}`;
     if (isMainLine) {
       if (column === undefined) {
-        return `${mark(">")} ${lineFormatted}`
+        return `${mark(">")} ${lineFormatted}`;
       }
       const spacing = stringToSpaces(
         `${asideSource} ${lineSourceTruncated.slice(
           0,
           column - columnRange.start - 1,
         )}`,
-      )
+      );
       return `${mark(">")} ${lineFormatted}
-  ${spacing}${mark("^")}`
+  ${spacing}${mark("^")}`;
     }
-    return `  ${lineFormatted}`
+    return `  ${lineFormatted}`;
   }).join(`
-`)
-}
+`);
+};
 
 const applyColumnRange = ({ start, end }, line) => {
   if (typeof start !== "number") {
-    throw new TypeError(`start must be a number, received ${start}`)
+    throw new TypeError(`start must be a number, received ${start}`);
   }
   if (typeof end !== "number") {
-    throw new TypeError(`end must be a number, received ${end}`)
+    throw new TypeError(`end must be a number, received ${end}`);
   }
   if (end < start) {
     throw new Error(
       `end must be greater than start, but ${end} is smaller than ${start}`,
-    )
+    );
   }
 
-  const prefix = "…"
-  const suffix = "…"
-  const lastIndex = line.length
+  const prefix = "…";
+  const suffix = "…";
+  const lastIndex = line.length;
 
   if (line.length === 0) {
     // don't show any ellipsis if the line is empty
     // because it's not truncated in that case
-    return ""
+    return "";
   }
 
-  const startTruncated = start > 0
-  const endTruncated = lastIndex > end
+  const startTruncated = start > 0;
+  const endTruncated = lastIndex > end;
 
-  let from = startTruncated ? start + prefix.length : start
-  let to = endTruncated ? end - suffix.length : end
-  if (to > lastIndex) to = lastIndex
+  let from = startTruncated ? start + prefix.length : start;
+  let to = endTruncated ? end - suffix.length : end;
+  if (to > lastIndex) to = lastIndex;
 
   if (start >= lastIndex || from === to) {
-    return ""
+    return "";
   }
 
-  let result = ""
+  let result = "";
   while (from < to) {
-    result += line[from]
-    from++
+    result += line[from];
+    from++;
   }
 
   if (result.length === 0) {
-    return ""
+    return "";
   }
   if (startTruncated && endTruncated) {
-    return `${prefix}${result}${suffix}`
+    return `${prefix}${result}${suffix}`;
   }
   if (startTruncated) {
-    return `${prefix}${result}`
+    return `${prefix}${result}`;
   }
   if (endTruncated) {
-    return `${result}${suffix}`
+    return `${result}${suffix}`;
   }
-  return result
-}
+  return result;
+};
 
-const stringToSpaces = (string) => string.replace(/[^\t]/g, " ")
+const stringToSpaces = (string) => string.replace(/[^\t]/g, " ");
 
 // const getLineRangeLength = ({ start, end }) => end - start
 
@@ -198,19 +198,19 @@ const moveLineRangeUp = ({ start, end }, number) => {
   return {
     start: start - number,
     end,
-  }
-}
+  };
+};
 
 const moveLineRangeDown = ({ start, end }, number) => {
   return {
     start,
     end: end + number,
-  }
-}
+  };
+};
 
 const lineRangeWithinLines = ({ start, end }, lines) => {
   return {
     start: start < 0 ? 0 : start,
     end: end > lines.length ? lines.length : end,
-  }
-}
+  };
+};

package/src/url_utils.js

@@ -1,25 +1,25 @@
-import { urlToOrigin } from "./url_to_origin.js"
-import { urlToExtension } from "./url_to_extension.js"
-import { urlToResource } from "./url_to_resource.js"
+import { urlToOrigin } from "./url_to_origin.js";
+import { urlToExtension } from "./url_to_extension.js";
+import { urlToResource } from "./url_to_resource.js";
 
 export const asUrlWithoutSearch = (url) => {
   if (url.includes("?")) {
-    const urlObject = new URL(url)
-    urlObject.search = ""
-    return urlObject.href
+    const urlObject = new URL(url);
+    urlObject.search = "";
+    return urlObject.href;
   }
-  return url
-}
+  return url;
+};
 
 export const isValidUrl = (url) => {
   try {
     // eslint-disable-next-line no-new
-    new URL(url)
-    return true
+    new URL(url);
+    return true;
   } catch (e) {
-    return false
+    return false;
   }
-}
+};
 
 // normalize url search params:
 // Using URLSearchParams to alter the url search params
@@ -30,83 +30,157 @@ export const normalizeUrl = (url) => {
   if (url.includes("?")) {
     // disable on data urls (would mess up base64 encoding)
     if (url.startsWith("data:")) {
-      return url
+      return url;
     }
-    return url.replace(/[=](?=&|$)/g, "")
+    return url.replace(/[=](?=&|$)/g, "");
   }
-  return url
-}
+  return url;
+};
 
 export const injectQueryParamsIntoSpecifier = (specifier, params) => {
   if (isValidUrl(specifier)) {
-    return injectQueryParams(specifier, params)
+    return injectQueryParams(specifier, params);
   }
-  const [beforeQuestion, afterQuestion = ""] = specifier.split("?")
-  const searchParams = new URLSearchParams(afterQuestion)
+  const [beforeQuestion, afterQuestion = ""] = specifier.split("?");
+  const searchParams = new URLSearchParams(afterQuestion);
   Object.keys(params).forEach((key) => {
-    searchParams.set(key, params[key])
-  })
-  const paramsString = searchParams.toString()
+    const value = params[key];
+    if (value === undefined) {
+      searchParams.delete(key);
+    } else {
+      searchParams.set(key, value);
+    }
+  });
+  let paramsString = searchParams.toString();
   if (paramsString) {
-    return `${beforeQuestion}?${paramsString}`
+    paramsString = paramsString.replace(/[=](?=&|$)/g, "");
+    return `${beforeQuestion}?${paramsString}`;
   }
-  return specifier
-}
+  return beforeQuestion;
+};
 
 export const injectQueryParams = (url, params) => {
-  const urlObject = new URL(url)
+  const urlObject = new URL(url);
+  const { searchParams } = urlObject;
   Object.keys(params).forEach((key) => {
-    urlObject.searchParams.set(key, params[key])
-  })
-  const urlWithParams = urlObject.href
-  return urlWithParams
-}
+    const value = params[key];
+    if (value === undefined) {
+      searchParams.delete(key);
+    } else {
+      searchParams.set(key, value);
+    }
+  });
+  const urlWithParams = urlObject.href;
+  return normalizeUrl(urlWithParams);
+};
+
+export const injectQueryParamWithoutEncoding = (url, key, value) => {
+  const urlObject = new URL(url);
+  let { origin, pathname, search, hash } = urlObject;
+  // origin is "null" for "file://" urls with Node.js
+  if (origin === "null" && urlObject.href.startsWith("file:")) {
+    origin = "file://";
+  }
+  if (search === "") {
+    search = `?${key}=${value}`;
+  } else {
+    search += `${key}=${value}`;
+  }
+  return `${origin}${pathname}${search}${hash}`;
+};
+export const injectQueryParamIntoSpecifierWithoutEncoding = (
+  specifier,
+  key,
+  value,
+) => {
+  if (isValidUrl(specifier)) {
+    return injectQueryParams(specifier, key, value);
+  }
+  const [beforeQuestion, afterQuestion = ""] = specifier.split("?");
+  const searchParams = new URLSearchParams(afterQuestion);
+  let search = searchParams.toString();
+  if (search === "") {
+    search = `?${key}=${value}`;
+  } else {
+    search = `?${search}&${key}=${value}`;
+  }
+  return `${beforeQuestion}${search}`;
+};
+
+export const renderUrlOrRelativeUrlFilename = (urlOrRelativeUrl, renderer) => {
+  const questionIndex = urlOrRelativeUrl.indexOf("?");
+  const beforeQuestion =
+    questionIndex === -1
+      ? urlOrRelativeUrl
+      : urlOrRelativeUrl.slice(0, questionIndex);
+  const afterQuestion =
+    questionIndex === -1 ? "" : urlOrRelativeUrl.slice(questionIndex);
+  const beforeLastSlash = beforeQuestion.endsWith("/")
+    ? beforeQuestion.slice(0, -1)
+    : beforeQuestion;
+  const slashLastIndex = beforeLastSlash.lastIndexOf("/");
+  const beforeFilename =
+    slashLastIndex === -1 ? "" : beforeQuestion.slice(0, slashLastIndex + 1);
+  const filename =
+    slashLastIndex === -1
+      ? beforeQuestion
+      : beforeQuestion.slice(slashLastIndex + 1);
+  const dotLastIndex = filename.lastIndexOf(".");
+  const basename =
+    dotLastIndex === -1 ? filename : filename.slice(0, dotLastIndex);
+  const extension = dotLastIndex === -1 ? "" : filename.slice(dotLastIndex);
+  const newFilename = renderer({
+    basename,
+    extension,
+  });
+  return `${beforeFilename}${newFilename}${afterQuestion}`;
+};
 
 export const setUrlExtension = (url, extension) => {
-  const origin = urlToOrigin(url)
-  const currentExtension = urlToExtension(url)
-  const resource = urlToResource(url)
-  const [pathname, search] = resource.split("?")
+  const origin = urlToOrigin(url);
+  const currentExtension = urlToExtension(url);
+  const resource = urlToResource(url);
+  const [pathname, search] = resource.split("?");
   const pathnameWithoutExtension = currentExtension
     ? pathname.slice(0, -currentExtension.length)
-    : pathname
-  const newPathname = `${pathnameWithoutExtension}${extension}`
-  return `${origin}${newPathname}${search ? `?${search}` : ""}`
-}
+    : pathname;
+  const newPathname = `${pathnameWithoutExtension}${extension}`;
+  return `${origin}${newPathname}${search ? `?${search}` : ""}`;
+};
 
 export const setUrlFilename = (url, filename) => {
-  const urlObject = new URL(url)
-  let { origin, search, hash } = urlObject
+  const urlObject = new URL(url);
+  let { origin, search, hash } = urlObject;
   // origin is "null" for "file://" urls with Node.js
   if (origin === "null" && urlObject.href.startsWith("file:")) {
-    origin = "file://"
+    origin = "file://";
   }
-  const parentPathname = new URL("./", urlObject).pathname
-  return `${origin}${parentPathname}${filename}${search}${hash}`
-}
+  const parentPathname = new URL("./", urlObject).pathname;
+  return `${origin}${parentPathname}${filename}${search}${hash}`;
+};
 
 export const ensurePathnameTrailingSlash = (url) => {
-  const urlObject = new URL(url)
-  const { pathname } = urlObject
+  const urlObject = new URL(url);
+  const { pathname } = urlObject;
   if (pathname.endsWith("/")) {
-    return url
+    return url;
   }
-  let { origin } = urlObject
+  let { origin } = urlObject;
   // origin is "null" for "file://" urls with Node.js
   if (origin === "null" && urlObject.href.startsWith("file:")) {
-    origin = "file://"
+    origin = "file://";
   }
-  const { search, hash } = urlObject
-  return `${origin}${pathname}/${search}${hash}`
-}
+  const { search, hash } = urlObject;
+  return `${origin}${pathname}/${search}${hash}`;
+};
 
 export const asUrlUntilPathname = (url) => {
-  const urlObject = new URL(url)
-  let { origin, pathname } = urlObject
+  const urlObject = new URL(url);
+  let { origin, pathname } = urlObject;
   // origin is "null" for "file://" urls with Node.js
   if (origin === "null" && urlObject.href.startsWith("file:")) {
-    origin = "file://"
+    origin = "file://";
   }
-  const urlUntilPathname = `${origin}${pathname}`
-  return urlUntilPathname
-}
+  const urlUntilPathname = `${origin}${pathname}`;
+  return urlUntilPathname;
+};

package/src/windows_file_path_utils.js

@@ -1,16 +1,16 @@
 export const startsWithWindowsDriveLetter = (string) => {
-  const firstChar = string[0]
-  if (!/[a-zA-Z]/.test(firstChar)) return false
+  const firstChar = string[0];
+  if (!/[a-zA-Z]/.test(firstChar)) return false;
 
-  const secondChar = string[1]
-  if (secondChar !== ":") return false
+  const secondChar = string[1];
+  if (secondChar !== ":") return false;
 
-  return true
-}
+  return true;
+};
 
 export const windowsFilePathToUrl = (windowsFilePath) => {
-  return `file:///${replaceBackSlashesWithSlashes(windowsFilePath)}`
-}
+  return `file:///${replaceBackSlashesWithSlashes(windowsFilePath)}`;
+};
 
 export const replaceBackSlashesWithSlashes = (string) =>
-  string.replace(/\\/g, "/")
+  string.replace(/\\/g, "/");