@jsenv/sourcemap 1.0.10 → 1.2.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@jsenv/sourcemap",
-  "version": "1.0.10",
+  "version": "1.2.0",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jsenv/jsenv-core",
-    "directory": "packages/utils"
+    "url": "https://github.com/jsenv/core",
+    "directory": "packages/independent/utils"
   },
   "publishConfig": {
     "access": "public"
@@ -19,8 +19,8 @@
     "test": "node --conditions=development ./scripts/test.mjs"
   },
   "dependencies": {
-    "@jsenv/urls": "2.0.0",
-    "magic-string": "0.30.0",
+    "@jsenv/urls": "2.2.0",
+    "magic-string": "0.30.2",
     "source-map-js": "1.0.2"
   }
 }

package/scripts/test.mjs

@@ -1,15 +1,15 @@
-import { executeTestPlan, nodeWorkerThread } from "@jsenv/core"
+import { executeTestPlan, nodeWorkerThread } from "@jsenv/test";
 
 await executeTestPlan({
   rootDirectoryUrl: new URL("../", import.meta.url),
   testPlan: {
     "./tests/**/*.test.mjs": {
       node: {
-        runtime: nodeWorkerThread,
+        runtime: nodeWorkerThread(),
       },
     },
   },
   failFast: process.argv.includes("--workspace"),
-  completedExecutionLogMerging: process.argv.includes("--workspace"),
-  coverageEnabled: process.argv.includes("--coverage"),
-})
+  logShortForCompletedExecutions: true,
+  logMergeForCompletedExecutions: process.argv.includes("--workspace"),
+});

package/src/error_stack_remap/detailed_message.js

@@ -1,9 +1,9 @@
 // duplicated from @jsenv/log to avoid the dependency
 export const createDetailedMessage = (message, details = {}) => {
-  let string = `${message}`
+  let string = `${message}`;
 
   Object.keys(details).forEach((key) => {
-    const value = details[key]
+    const value = details[key];
     string += `
   --- ${key} ---
   ${
@@ -11,8 +11,8 @@ export const createDetailedMessage = (message, details = {}) => {
       ? value.join(`
   `)
       : value
-  }`
-  })
+  }`;
+  });
 
-  return string
-}
+  return string;
+};

package/src/error_stack_remap/install_error_stack_remapping.js

@@ -1,6 +1,6 @@
-import { createDetailedMessage } from "./detailed_message.js"
-import { remapStack } from "./remap_stack.js"
-import { stringifyStack } from "./stringify_stack.js"
+import { createDetailedMessage } from "./detailed_message.js";
+import { remapStack } from "./remap_stack.js";
+import { stringifyStack } from "./stringify_stack.js";
 
 export const installErrorStackRemapping = ({
   fetchFile,
@@ -9,52 +9,52 @@ export const installErrorStackRemapping = ({
   indent = "  ",
 }) => {
   if (typeof fetchFile !== "function") {
-    throw new TypeError(`fetchFile must be a function, got ${fetchFile}`)
+    throw new TypeError(`fetchFile must be a function, got ${fetchFile}`);
   }
   if (typeof SourceMapConsumer !== "function") {
     throw new TypeError(
       `sourceMapConsumer must be a function, got ${SourceMapConsumer}`,
-    )
+    );
   }
   if (typeof indent !== "string") {
-    throw new TypeError(`indent must be a string, got ${indent}`)
+    throw new TypeError(`indent must be a string, got ${indent}`);
   }
 
-  const errorRemappingCache = new WeakMap()
-  const errorRemapFailureCallbackMap = new WeakMap()
+  const errorRemappingCache = new WeakMap();
+  const errorRemapFailureCallbackMap = new WeakMap();
 
-  let installed = false
-  const previousPrepareStackTrace = Error.prepareStackTrace
+  let installed = false;
+  const previousPrepareStackTrace = Error.prepareStackTrace;
   const install = () => {
-    if (installed) return
-    installed = true
-    Error.prepareStackTrace = prepareStackTrace
-  }
+    if (installed) return;
+    installed = true;
+    Error.prepareStackTrace = prepareStackTrace;
+  };
 
   const uninstall = () => {
-    if (!installed) return
-    installed = false
-    Error.prepareStackTrace = previousPrepareStackTrace
-  }
+    if (!installed) return;
+    installed = false;
+    Error.prepareStackTrace = previousPrepareStackTrace;
+  };
 
   // ensure we do not use prepareStackTrace for thoose error
   // otherwise we would recursively remap error stack
   // and if the reason causing the failure is still here
   // it would create an infinite loop
   const readErrorStack = (error) => {
-    uninstall()
-    const stack = error.stack
-    install()
-    return stack
-  }
+    uninstall();
+    const stack = error.stack;
+    install();
+    return stack;
+  };
 
   const prepareStackTrace = (error, stack) => {
     const onFailure = (failureData) => {
-      const failureCallbackArray = errorRemapFailureCallbackMap.get(error)
+      const failureCallbackArray = errorRemapFailureCallbackMap.get(error);
       if (failureCallbackArray) {
-        failureCallbackArray.forEach((callback) => callback(failureData))
+        failureCallbackArray.forEach((callback) => callback(failureData));
       }
-    }
+    };
 
     const stackRemappingPromise = remapStack({
       stack,
@@ -65,77 +65,77 @@ export const installErrorStackRemapping = ({
       readErrorStack,
       indent,
       onFailure,
-    })
-    errorRemappingCache.set(error, stackRemappingPromise)
+    });
+    errorRemappingCache.set(error, stackRemappingPromise);
 
-    return stringifyStack(stack, { error, indent })
-  }
+    return stringifyStack(stack, { error, indent });
+  };
 
   const getErrorOriginalStackString = async (
     error,
     {
       onFailure = (message) => {
-        console.warn(message)
+        console.warn(message);
       },
     } = {},
   ) => {
     if (onFailure) {
-      const remapFailureCallbackArray = errorRemapFailureCallbackMap.get(error)
+      const remapFailureCallbackArray = errorRemapFailureCallbackMap.get(error);
       if (remapFailureCallbackArray) {
         errorRemapFailureCallbackMap.set(error, [
           ...remapFailureCallbackArray,
           onFailure,
-        ])
+        ]);
       } else {
-        errorRemapFailureCallbackMap.set(error, [onFailure])
+        errorRemapFailureCallbackMap.set(error, [onFailure]);
       }
     }
 
     // ensure Error.prepareStackTrace gets triggered by reading error.stack now
-    const { stack } = error
-    const promise = errorRemappingCache.get(error)
+    const { stack } = error;
+    const promise = errorRemappingCache.get(error);
 
     if (promise) {
       try {
-        const originalCallsites = await promise
-        errorRemapFailureCallbackMap.get(error)
+        const originalCallsites = await promise;
+        errorRemapFailureCallbackMap.get(error);
 
-        const firstCall = originalCallsites[0]
+        const firstCall = originalCallsites[0];
         if (firstCall) {
           Object.assign(error, {
             filename: firstCall.getFileName(),
             lineno: firstCall.getLineNumber(),
             columnno: firstCall.getColumnNumber(),
-          })
+          });
         }
-        return stringifyStack(originalCallsites, { error, indent })
+        return stringifyStack(originalCallsites, { error, indent });
       } catch (e) {
         onFailure(
           createDetailedMessage(`error while computing original stack.`, {
             ["stack from error while computing"]: readErrorStack(e),
             ["stack from error to remap"]: stack,
           }),
-        )
-        return stack
+        );
+        return stack;
       }
     }
 
-    return stack
-  }
+    return stack;
+  };
 
-  install()
+  install();
 
-  return { getErrorOriginalStackString, uninstall }
-}
+  return { getErrorOriginalStackString, uninstall };
+};
 
 const memoizeFetch = (fetchUrl) => {
-  const urlCache = {}
+  const urlCache = {};
   return async (url) => {
     if (url in urlCache) {
-      return urlCache[url]
+      return urlCache[url];
     }
-    const responsePromise = fetchUrl(url)
-    urlCache[url] = responsePromise
-    return responsePromise
-  }
-}
+    const responsePromise = fetchUrl(url);
+    urlCache[url] = responsePromise;
+    return responsePromise;
+  };
+};

package/src/error_stack_remap/remap_call_site.js

@@ -1,20 +1,20 @@
-import { remapSourcePosition } from "./remap_source_position.js"
+import { remapSourcePosition } from "./remap_source_position.js";
 
 export const remapCallSite = async (
   callSite,
   { urlToSourcemapConsumer, resolveFile, readErrorStack, onFailure },
 ) => {
   if (callSite.isNative()) {
-    return callSite
+    return callSite;
   }
 
   // Most call sites will return the source file from getFileName(), but code
   // passed to eval() ending in "//# sourceURL=..." will return the source file
   // from getScriptNameOrSourceURL() instead
-  const source = callSite.getFileName() || callSite.getScriptNameOrSourceURL()
+  const source = callSite.getFileName() || callSite.getScriptNameOrSourceURL();
   if (source) {
-    const line = callSite.getLineNumber()
-    const column = callSite.getColumnNumber() - 1
+    const line = callSite.getLineNumber();
+    const column = callSite.getColumnNumber() - 1;
     const originalPosition = await remapSourcePosition({
       url: resolveFile(source),
       line,
@@ -22,50 +22,50 @@ export const remapCallSite = async (
       resolveFile,
       urlToSourcemapConsumer,
       readErrorStack,
-    })
+    });
 
-    const callSiteClone = cloneCallSite(callSite)
+    const callSiteClone = cloneCallSite(callSite);
 
     callSiteClone.getFunctionName = () =>
-      originalPosition.name || callSite.getFunctionName()
-    callSiteClone.getFileName = () => originalPosition.source
-    callSiteClone.getLineNumber = () => originalPosition.line
-    callSiteClone.getColumnNumber = () => originalPosition.column + 1
-    callSiteClone.getScriptNameOrSourceURL = () => originalPosition.source
+      originalPosition.name || callSite.getFunctionName();
+    callSiteClone.getFileName = () => originalPosition.source;
+    callSiteClone.getLineNumber = () => originalPosition.line;
+    callSiteClone.getColumnNumber = () => originalPosition.column + 1;
+    callSiteClone.getScriptNameOrSourceURL = () => originalPosition.source;
 
-    return callSiteClone
+    return callSiteClone;
   }
 
   // Code called using eval() needs special handling
   if (callSite.isEval()) {
-    const origin = callSite.getEvalOrigin()
+    const origin = callSite.getEvalOrigin();
     if (origin) {
-      const callSiteClone = cloneCallSite(callSite)
+      const callSiteClone = cloneCallSite(callSite);
       const originalEvalOrigin = await remapEvalOrigin(origin, {
         resolveFile,
         urlToSourcemapConsumer,
         readErrorStack,
         onFailure,
-      })
-      callSiteClone.getEvalOrigin = () => originalEvalOrigin
-      return callSiteClone
+      });
+      callSiteClone.getEvalOrigin = () => originalEvalOrigin;
+      return callSiteClone;
     }
-    return callSite
+    return callSite;
   }
 
   // If we get here then we were unable to change the source position
-  return callSite
-}
+  return callSite;
+};
 
 const cloneCallSite = (callSite) => {
-  const callSiteClone = {}
+  const callSiteClone = {};
   methods.forEach((name) => {
-    callSiteClone[name] = () => callSite[name]()
-  })
-  callSiteClone.toString = () => callSiteToFunctionCall(callSiteClone)
+    callSiteClone[name] = () => callSite[name]();
+  });
+  callSiteClone.toString = () => callSiteToFunctionCall(callSiteClone);
 
-  return callSiteClone
-}
+  return callSiteClone;
+};
 
 const methods = [
   "getColumnNumber",
@@ -84,99 +84,99 @@ const methods = [
   "isNative",
   "isToplevel",
   "toString",
-]
+];
 
 const callSiteToFunctionCall = (callSite) => {
-  const fileLocation = callSiteToFileLocation(callSite)
-  const isConstructor = callSite.isConstructor()
-  const isMethodCall = !callSite.isToplevel() && !isConstructor
+  const fileLocation = callSiteToFileLocation(callSite);
+  const isConstructor = callSite.isConstructor();
+  const isMethodCall = !callSite.isToplevel() && !isConstructor;
 
   if (isMethodCall) {
-    return `${callSiteToMethodCall(callSite)} (${fileLocation})`
+    return `${callSiteToMethodCall(callSite)} (${fileLocation})`;
   }
 
-  const functionName = callSite.getFunctionName()
+  const functionName = callSite.getFunctionName();
   if (isConstructor) {
-    return `new ${functionName || "<anonymous>"} (${fileLocation})`
+    return `new ${functionName || "<anonymous>"} (${fileLocation})`;
   }
 
   if (functionName) {
-    return `${functionName} (${fileLocation})`
+    return `${functionName} (${fileLocation})`;
   }
 
-  return `${fileLocation}`
-}
+  return `${fileLocation}`;
+};
 
 const callSiteToMethodCall = (callSite) => {
-  const functionName = callSite.getFunctionName()
-  const typeName = callSiteToType(callSite)
+  const functionName = callSite.getFunctionName();
+  const typeName = callSiteToType(callSite);
 
   if (!functionName) {
-    return `${typeName}.<anonymous>`
+    return `${typeName}.<anonymous>`;
   }
 
-  const methodName = callSite.getMethodName()
-  const as = generateAs({ methodName, functionName })
+  const methodName = callSite.getMethodName();
+  const as = generateAs({ methodName, functionName });
 
   if (typeName && !functionName.startsWith(typeName)) {
-    return `${typeName}.${functionName}${as}`
+    return `${typeName}.${functionName}${as}`;
   }
 
-  return `${functionName}${as}`
-}
+  return `${functionName}${as}`;
+};
 
 const generateAs = ({ methodName, functionName }) => {
-  if (!methodName) return ""
+  if (!methodName) return "";
   if (
     functionName.indexOf(`.${methodName}`) ===
     functionName.length - methodName.length - 1
   )
-    return ""
-  return ` [as ${methodName}]`
-}
+    return "";
+  return ` [as ${methodName}]`;
+};
 
 const callSiteToType = (callSite) => {
-  const typeName = callSite.getTypeName()
+  const typeName = callSite.getTypeName();
   // Fixes shim to be backward compatible with Node v0 to v4
   if (typeName === "[object Object]") {
-    return "null"
+    return "null";
   }
-  return typeName
-}
+  return typeName;
+};
 
 const callSiteToFileLocation = (callSite) => {
-  if (callSite.isNative()) return "native"
+  if (callSite.isNative()) return "native";
 
-  const sourceFile = callSiteToSourceFile(callSite)
-  const lineNumber = callSite.getLineNumber()
+  const sourceFile = callSiteToSourceFile(callSite);
+  const lineNumber = callSite.getLineNumber();
   if (lineNumber === null) {
-    return sourceFile
+    return sourceFile;
   }
 
-  const columnNumber = callSite.getColumnNumber()
+  const columnNumber = callSite.getColumnNumber();
   if (!columnNumber) {
-    return `${sourceFile}:${lineNumber}`
+    return `${sourceFile}:${lineNumber}`;
   }
 
-  return `${sourceFile}:${lineNumber}:${columnNumber}`
-}
+  return `${sourceFile}:${lineNumber}:${columnNumber}`;
+};
 
 const callSiteToSourceFile = (callSite) => {
-  const fileName = callSite.getScriptNameOrSourceURL()
+  const fileName = callSite.getScriptNameOrSourceURL();
 
   if (fileName) {
-    return fileName
+    return fileName;
   }
 
   // Source code does not originate from a file and is not native, but we
   // can still get the source position inside the source string, e.g. in
   // an eval string.
   if (callSite.isEval()) {
-    return `${callSite.getEvalOrigin()}, <anonymous>`
+    return `${callSite.getEvalOrigin()}, <anonymous>`;
   }
 
-  return "<anonymous>"
-}
+  return "<anonymous>";
+};
 
 // Parses code generated by FormatEvalOrigin(), a function inside V8:
 // https://code.google.com/p/v8/source/browse/trunk/src/messages.js
@@ -187,34 +187,34 @@ const remapEvalOrigin = async (
   // Most eval() calls are in this format
   const topLevelEvalMatch = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(
     origin,
-  )
+  );
   if (topLevelEvalMatch) {
-    const source = topLevelEvalMatch[2]
-    const line = Number(topLevelEvalMatch[3])
-    const column = topLevelEvalMatch[4] - 1
+    const source = topLevelEvalMatch[2];
+    const line = Number(topLevelEvalMatch[3]);
+    const column = topLevelEvalMatch[4] - 1;
     const originalPosition = await remapSourcePosition({
       url: resolveFile(source),
       line,
       column,
       resolveFile,
       urlToSourcemapConsumer,
-    })
+    });
     return `eval at ${topLevelEvalMatch[1]} (${originalPosition.source}:${
       originalPosition.line
-    }:${originalPosition.column + 1})`
+    }:${originalPosition.column + 1})`;
   }
 
   // Parse nested eval() calls using recursion
-  const nestedEvalMatch = /^eval at ([^(]+) \((.+)\)$/.exec(origin)
+  const nestedEvalMatch = /^eval at ([^(]+) \((.+)\)$/.exec(origin);
   if (nestedEvalMatch) {
     const originalEvalOrigin = await remapEvalOrigin(nestedEvalMatch[2], {
       resolveFile,
       urlToSourcemapConsumer,
       onFailure,
-    })
-    return `eval at ${nestedEvalMatch[1]} (${originalEvalOrigin})`
+    });
+    return `eval at ${nestedEvalMatch[1]} (${originalEvalOrigin})`;
   }
 
   // Make sure we still return useful information if we didn't find anything
-  return origin
-}
+  return origin;
+};

package/src/error_stack_remap/remap_source_position.js

@@ -1,4 +1,4 @@
-import { createDetailedMessage } from "./detailed_message.js"
+import { createDetailedMessage } from "./detailed_message.js";
 
 export const remapSourcePosition = async ({
   url,
@@ -8,30 +8,30 @@ export const remapSourcePosition = async ({
   urlToSourcemapConsumer,
   readErrorStack = (e) => e.stack,
 }) => {
-  const position = { url, line, column }
-  const sourceMapConsumer = await urlToSourcemapConsumer(url)
+  const position = { url, line, column };
+  const sourceMapConsumer = await urlToSourcemapConsumer(url);
 
   if (!sourceMapConsumer) {
-    return position
+    return position;
   }
 
   try {
-    const originalPosition = sourceMapConsumer.originalPositionFor(position)
+    const originalPosition = sourceMapConsumer.originalPositionFor(position);
 
     // Only return the original position if a matching line was found. If no
     // matching line is found then we return position instead, which will cause
     // the stack trace to print the path and line for the compiled file. It is
     // better to give a precise location in the compiled file than a vague
     // location in the original file.
-    const originalSource = originalPosition.source
+    const originalSource = originalPosition.source;
     if (originalSource === null) {
-      return position
+      return position;
     }
     return {
       url: resolveFile(originalSource, url),
       line: originalPosition.line,
       column: originalPosition.column,
-    }
+    };
   } catch (e) {
     console.warn(
       createDetailedMessage(`error while remapping position.`, {
@@ -40,7 +40,7 @@ export const remapSourcePosition = async ({
         ["line"]: line,
         ["column"]: column,
       }),
-    )
-    return position
+    );
+    return position;
   }
-}
+};