@jsenv/plugin-commonjs 2.0.4 → 2.0.6

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@jsenv/plugin-commonjs",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jsenv/jsenv-core",
+    "url": "https://github.com/jsenv/core",
     "directory": "packages/jsenv-plugin-commonjs"
   },
   "publishConfig": {
@@ -25,20 +25,20 @@
   },
   "dependencies": {
     "@jsenv/filesystem": "4.2.3",
-    "@jsenv/log": "3.3.4",
+    "@jsenv/log": "3.3.5",
     "@jsenv/url-meta": "8.1.0",
     "@jsenv/urls": "2.0.0",
-    "@rollup/plugin-commonjs": "24.1.0",
+    "@rollup/plugin-commonjs": "25.0.0",
     "@rollup/plugin-json": "6.0.0",
     "@rollup/plugin-node-resolve": "15.0.2",
     "@rollup/plugin-replace": "5.0.2",
     "cjs-module-lexer": "1.2.2",
     "is-valid-identifier": "2.0.2",
-    "resolve": "1.22.3",
-    "rollup": "3.20.4",
+    "resolve": "1.22.2",
+    "rollup": "3.21.8",
     "rollup-plugin-node-globals": "1.4.0",
     "rollup-plugin-polyfill-node": "0.12.0",
-    "vm2": "3.9.16"
+    "vm2": "3.9.19"
   },
   "devDependencies": {
     "@jsenv/core": "../../"

package/src/cjs_to_esm.js

@@ -1,14 +1,14 @@
-import { readFileSync } from "node:fs"
-import { ensureWindowsDriveLetter } from "@jsenv/filesystem"
+import { readFileSync } from "node:fs";
+import { ensureWindowsDriveLetter } from "@jsenv/filesystem";
 
 import {
   setUrlExtension,
   setUrlFilename,
   urlToExtension,
   urlToBasename,
-} from "@jsenv/urls"
-import { commonJsToJsModuleRaw } from "./cjs_to_esm_raw.js"
-import { reuseOrCreateCompiledFile } from "./compile_cache/compiled_file_cache.js"
+} from "@jsenv/urls";
+import { commonJsToJsModuleRaw } from "./cjs_to_esm_raw.js";
+import { reuseOrCreateCompiledFile } from "./compile_cache/compiled_file_cache.js";
 
 export const commonJsToJsModule = ({
   logLevel,
@@ -23,7 +23,7 @@ export const commonJsToJsModule = ({
       url: sourceFileUrl,
       compileCacheDirectoryUrl,
       processEnvNodeEnv,
-    })
+    });
 
     return reuseOrCreateCompiledFile({
       logLevel,
@@ -36,28 +36,28 @@ export const commonJsToJsModule = ({
           sourceFileUrl,
           processEnvNodeEnv,
           ...rest,
-        })
+        });
         const assets = extractCompileAssets({
           sourceUrl: sourceFileUrl,
           sourceContent: String(readFileSync(new URL(sourceFileUrl))),
           compiledUrl: compiledFileUrl,
           compiledContent: content,
           sourcemap,
-        })
+        });
         return {
           content,
           sourcemap,
           assets,
-        }
+        };
       },
-    })
+    });
   }
   return commonJsToJsModuleRaw({
     logLevel,
     sourceFileUrl,
     ...rest,
-  })
-}
+  });
+};
 
 const extractCompileAssets = ({
   sourceUrl,
@@ -65,35 +65,35 @@ const extractCompileAssets = ({
   compiledUrl,
   sourcemap,
 }) => {
-  const compileAssets = {}
+  const compileAssets = {};
 
   // ensure the source file is part of sources no matter what
   // it covers cases where sourcemap.sources is empty
   // or do not contain the real source file
   // there is a check to prevent duplicate sources in case the sourcemap is correct and contains
   // the source file in sourcemap.sources
-  compileAssets[sourceUrl] = { type: "source", content: sourceContent }
+  compileAssets[sourceUrl] = { type: "source", content: sourceContent };
   if (sourcemap) {
     sourcemap.sources.forEach((source, index) => {
       if (source.startsWith("file://")) {
         const contentFromSourcemap = sourcemap.sourcesContent
           ? sourcemap.sourcesContent[index]
-          : null
+          : null;
         const content =
-          contentFromSourcemap || String(readFileSync(new URL(source)))
-        compileAssets[source] = { type: "source", content }
+          contentFromSourcemap || String(readFileSync(new URL(source)));
+        compileAssets[source] = { type: "source", content };
       }
-    })
-    const sourcemapUrl = setUrlExtension(compiledUrl, ".map")
-    const sourcemapContent = JSON.stringify(sourcemap)
+    });
+    const sourcemapUrl = setUrlExtension(compiledUrl, ".map");
+    const sourcemapContent = JSON.stringify(sourcemap);
     compileAssets[sourcemapUrl] = {
       type: "sourcemap",
       content: sourcemapContent,
-    }
+    };
   }
 
-  return compileAssets
-}
+  return compileAssets;
+};
 
 const determineCompiledFileUrl = ({
   url,
@@ -101,11 +101,11 @@ const determineCompiledFileUrl = ({
   processEnvNodeEnv,
 }) => {
   if (processEnvNodeEnv) {
-    const basename = urlToBasename(url)
-    const extension = urlToExtension(url)
-    url = setUrlFilename(url, `${basename}.${processEnvNodeEnv}${extension}`)
+    const basename = urlToBasename(url);
+    const extension = urlToExtension(url);
+    url = setUrlFilename(url, `${basename}.${processEnvNodeEnv}${extension}`);
   }
-  const fsRootUrl = ensureWindowsDriveLetter("file:///", url)
-  url = `${compileCacheDirectoryUrl}@fs/${url.slice(fsRootUrl.length)}`
-  return url
-}
+  const fsRootUrl = ensureWindowsDriveLetter("file:///", url);
+  url = `${compileCacheDirectoryUrl}@fs/${url.slice(fsRootUrl.length)}`;
+  return url;
+};

package/src/cjs_to_esm_raw.js

@@ -1,7 +1,7 @@
-import { fileURLToPath } from "node:url"
-import { createLogger } from "@jsenv/log"
+import { fileURLToPath } from "node:url";
+import { createLogger } from "@jsenv/log";
 
-import { rollupPluginCommonJsNamedExports } from "./rollup_plugin_commonjs_named_exports.js"
+import { rollupPluginCommonJsNamedExports } from "./rollup_plugin_commonjs_named_exports.js";
 
 export const commonJsToJsModuleRaw = async ({
   logLevel,
@@ -20,17 +20,17 @@ export const commonJsToJsModuleRaw = async ({
   external = [],
   sourcemapExcludeSources,
 } = {}) => {
-  const logger = createLogger({ logLevel })
+  const logger = createLogger({ logLevel });
   if (!sourceFileUrl.startsWith("file:///")) {
     // it's possible to make rollup compatible with http:// for instance
     // however it's an exotic use case for now
     throw new Error(
       `compatible only with file:// protocol, got ${sourceFileUrl}`,
-    )
+    );
   }
-  const sourceFilePath = fileURLToPath(sourceFileUrl)
+  const sourceFilePath = fileURLToPath(sourceFileUrl);
 
-  const { nodeResolve } = await import("@rollup/plugin-node-resolve")
+  const { nodeResolve } = await import("@rollup/plugin-node-resolve");
   const nodeResolveRollupPlugin = nodeResolve({
     mainFields: browsers
       ? [
@@ -45,21 +45,21 @@ export const commonJsToJsModuleRaw = async ({
     extensions: [".mjs", ".cjs", ".js", ".json"],
     preferBuiltins: false,
     exportConditions: [],
-  })
+  });
 
   const { default: createJSONRollupPlugin } = await import(
     "@rollup/plugin-json"
-  )
+  );
   const jsonRollupPlugin = createJSONRollupPlugin({
     preferConst: true,
     indent: "  ",
     compact: false,
     namedExports: true,
-  })
+  });
 
   const { default: createReplaceRollupPlugin } = await import(
     "@rollup/plugin-replace"
-  )
+  );
   const replaceRollupPlugin = createReplaceRollupPlugin({
     preventAssignment: true,
     values: {
@@ -71,9 +71,9 @@ export const commonJsToJsModuleRaw = async ({
       ...(replaceGlobalDirname ? { __dirname: __dirnameReplacement } : {}),
       ...replaceMap,
     },
-  })
+  });
 
-  const { default: commonjs } = await import("@rollup/plugin-commonjs")
+  const { default: commonjs } = await import("@rollup/plugin-commonjs");
   // https://github.com/rollup/plugins/tree/master/packages/commonjs
   const commonJsRollupPlugin = commonjs({
     extensions: [".js", ".cjs"],
@@ -81,20 +81,20 @@ export const commonJsToJsModuleRaw = async ({
     // defaultIsModuleExports: true,
     // requireReturnsDefault: "namespace",
     requireReturnsDefault: "auto",
-  })
+  });
 
   const { default: createNodeGlobalRollupPlugin } = await import(
     "rollup-plugin-node-globals"
-  )
+  );
 
   const commonJsNamedExportsRollupPlugin = rollupPluginCommonJsNamedExports({
     logger,
-  })
+  });
   const { default: rollupPluginNodePolyfills } = await import(
     "rollup-plugin-polyfill-node"
-  )
+  );
 
-  const { rollup } = await import("rollup")
+  const { rollup } = await import("rollup");
   const rollupBuild = await rollup({
     input: sourceFilePath,
     external,
@@ -128,13 +128,13 @@ export const commonJsToJsModuleRaw = async ({
         warning.code === "UNRESOLVED_IMPORT" &&
         warning.id.endsWith("?commonjs-external")
       ) {
-        return
+        return;
       }
 
-      const { loc, message } = warning
+      const { loc, message } = warning;
       const logMessage = loc
         ? `${loc.file}:${loc.line}:${loc.column} ${message}`
-        : message
+        : message;
 
       // These warnings are usually harmless in packages, so don't show them by default
       if (
@@ -144,13 +144,13 @@ export const commonJsToJsModuleRaw = async ({
         warning.code === "EMPTY_BUNDLE" ||
         warning.code === "UNUSED_EXTERNAL_IMPORT"
       ) {
-        logger.debug(logMessage)
+        logger.debug(logMessage);
       } else {
-        logger.warn(logMessage)
+        logger.warn(logMessage);
       }
     },
-  })
-  const abstractDirUrl = new URL("./dist/", sourceFileUrl) // to help rollup generate property sourcemap paths
+  });
+  const abstractDirUrl = new URL("./dist/", sourceFileUrl); // to help rollup generate property sourcemap paths
   const generateOptions = {
     inlineDynamicImports: true,
     // https://rollupjs.org/guide/en#output-format
@@ -162,19 +162,19 @@ export const commonJsToJsModuleRaw = async ({
     exports: "named",
     dir: fileURLToPath(abstractDirUrl),
     sourcemapPathTransform: (relativePath) => {
-      const sourceUrl = new URL(relativePath, abstractDirUrl).href
-      return sourceUrl
+      const sourceUrl = new URL(relativePath, abstractDirUrl).href;
+      return sourceUrl;
     },
-  }
+  };
 
-  const { output } = await rollupBuild.generate(generateOptions)
-  const { code, map } = output[0]
+  const { output } = await rollupBuild.generate(generateOptions);
+  const { code, map } = output[0];
   return {
     content: code,
     sourcemap: map,
-  }
-}
+  };
+};
 
-const __filenameReplacement = `import.meta.url.slice('file:///'.length)`
+const __filenameReplacement = `import.meta.url.slice('file:///'.length)`;
 
-const __dirnameReplacement = `import.meta.url.slice('file:///'.length).replace(/[\\\/\\\\][^\\\/\\\\]*$/, '')`
+const __dirnameReplacement = `import.meta.url.slice('file:///'.length).replace(/[\\\/\\\\][^\\\/\\\\]*$/, '')`;

package/src/compile_cache/compiled_file_cache.js

@@ -1,15 +1,15 @@
-import { readFileSync, writeFileSync } from "node:fs"
-import { createLogger, UNICODE } from "@jsenv/log"
+import { readFileSync, writeFileSync } from "node:fs";
+import { createLogger, UNICODE } from "@jsenv/log";
 import {
   assertAndNormalizeFileUrl,
   ensureEmptyDirectory,
-} from "@jsenv/filesystem"
+} from "@jsenv/filesystem";
 
-import { validateCompileCache } from "./validate_compile_cache.js"
-import { createLockRegistry } from "./file_lock_registry.js"
-import { updateCompileCache } from "./update_compile_cache.js"
+import { validateCompileCache } from "./validate_compile_cache.js";
+import { createLockRegistry } from "./file_lock_registry.js";
+import { updateCompileCache } from "./update_compile_cache.js";
 
-const { lockForResource } = createLockRegistry()
+const { lockForResource } = createLockRegistry();
 
 export const reuseOrCreateCompiledFile = async ({
   logLevel,
@@ -20,11 +20,11 @@ export const reuseOrCreateCompiledFile = async ({
   compileCacheAssetsValidation,
   compile,
 }) => {
-  const logger = createLogger({ logLevel })
-  await initCompileCacheDirectory({ logger, compileCacheDirectoryUrl })
-  sourceFileUrl = assertAndNormalizeFileUrl(sourceFileUrl)
+  const logger = createLogger({ logLevel });
+  await initCompileCacheDirectory({ logger, compileCacheDirectoryUrl });
+  sourceFileUrl = assertAndNormalizeFileUrl(sourceFileUrl);
   if (typeof compile !== "function") {
-    throw new TypeError(`compile must be a function, got ${compile}`)
+    throw new TypeError(`compile must be a function, got ${compile}`);
   }
 
   const getCacheValidity = () => {
@@ -33,146 +33,146 @@ export const reuseOrCreateCompiledFile = async ({
       compiledFileUrl,
       compileCacheStrategy,
       compileCacheAssetsValidation,
-    })
-    return cacheValidity
-  }
+    });
+    return cacheValidity;
+  };
 
   return startAsap(
     async () => {
-      logger.debug(`check cache for ${compiledFileUrl}`)
-      const cacheValidity = getCacheValidity()
+      logger.debug(`check cache for ${compiledFileUrl}`);
+      const cacheValidity = getCacheValidity();
       if (cacheValidity.isValid) {
-        logger.debug(`${UNICODE.OK} found a valid cache`)
-        const compileInfo = cacheValidity.compileInfo.data
-        const content = String(cacheValidity.compiledFile.data.buffer)
-        const assets = {}
-        let sourcemap = null
+        logger.debug(`${UNICODE.OK} found a valid cache`);
+        const compileInfo = cacheValidity.compileInfo.data;
+        const content = String(cacheValidity.compiledFile.data.buffer);
+        const assets = {};
+        let sourcemap = null;
         Object.keys(compileInfo.assetInfos).forEach((assetRelativeUrl) => {
-          const assetUrl = new URL(assetRelativeUrl, compiledFileUrl).href
-          const assetValidity = cacheValidity.assets.data[assetUrl]
+          const assetUrl = new URL(assetRelativeUrl, compiledFileUrl).href;
+          const assetValidity = cacheValidity.assets.data[assetUrl];
           const asset = {
             type: compileInfo.assetInfos[assetRelativeUrl].type,
             etag: compileInfo.assetInfos[assetRelativeUrl].etag,
             content: assetValidity.data.content,
-          }
-          assets[assetUrl] = asset
+          };
+          assets[assetUrl] = asset;
           if (asset.type === "sourcemap") {
-            sourcemap = assetValidity.data.sourcemap
+            sourcemap = assetValidity.data.sourcemap;
           }
-        })
+        });
         return {
           isValid: () => getCacheValidity().isValid,
           content,
           sourcemap,
-        }
+        };
       }
       if (cacheValidity.code === "SOURCES_EMPTY") {
         logger.warn(
           `${UNICODE.WARN} meta.sources is empty for ${compiledFileUrl}`,
-        )
+        );
       }
-      logger.debug(`${UNICODE.INFO} cache not found or invalid`)
+      logger.debug(`${UNICODE.INFO} cache not found or invalid`);
       const compileInfoIsValid = cacheValidity.compileInfo
         ? cacheValidity.compileInfo.isValid
-        : false
-      const fileContentAsBuffer = readFileSync(new URL(sourceFileUrl))
-      const fileContentAsString = String(fileContentAsBuffer)
+        : false;
+      const fileContentAsBuffer = readFileSync(new URL(sourceFileUrl));
+      const fileContentAsString = String(fileContentAsBuffer);
 
       const compileResult = await compile({
         content: fileContentAsString,
-      })
+      });
       if (typeof compileResult !== "object" || compileResult === null) {
         throw new TypeError(
           `compile must return an object, got ${compileResult}`,
-        )
+        );
       }
-      const { content, sourcemap, assets } = compileResult
+      const { content, sourcemap, assets } = compileResult;
       updateCompileCache({
         logger,
         compiledFileUrl,
         content,
         assets,
         compileResultStatus: compileInfoIsValid ? "updated" : "created",
-      })
+      });
       return {
         isValid: () => getCacheValidity().isValid,
         content,
         sourcemap,
-      }
+      };
     },
     {
       compiledFileUrl,
     },
-  )
-}
+  );
+};
 
-const initalized = {}
+const initalized = {};
 const initCompileCacheDirectory = async ({
   logger,
   compileCacheDirectoryUrl,
 }) => {
   if (initalized[compileCacheDirectoryUrl]) {
-    return
+    return;
   }
-  initalized[compileCacheDirectoryUrl] = true
-  logger.debug(`check compile directory at ${compileCacheDirectoryUrl}`)
+  initalized[compileCacheDirectoryUrl] = true;
+  logger.debug(`check compile directory at ${compileCacheDirectoryUrl}`);
   const compileContextJsonFileUrl = new URL(
     "./__compile_context__.json",
     compileCacheDirectoryUrl,
-  )
+  );
   const version = JSON.parse(
     readFileSync(new URL("../../package.json", import.meta.url)),
-  ).version
+  ).version;
   const compileContext = readCompileContextFile({
     logger,
     compileContextJsonFileUrl,
-  })
+  });
   if (compileContext && compileContext.version === version) {
-    logger.debug(`${UNICODE.OK} reuse compile directory`)
+    logger.debug(`${UNICODE.OK} reuse compile directory`);
   } else {
     if (compileContext) {
-      logger.debug(`${UNICODE.WARN} clean existing directory`)
+      logger.debug(`${UNICODE.WARN} clean existing directory`);
     } else {
-      logger.debug(`${UNICODE.INFO} create an empty directory`)
+      logger.debug(`${UNICODE.INFO} create an empty directory`);
     }
-    await ensureEmptyDirectory(compileCacheDirectoryUrl)
+    await ensureEmptyDirectory(compileCacheDirectoryUrl);
     writeFileSync(
       compileContextJsonFileUrl,
       JSON.stringify({ version }, null, "  "),
-    )
+    );
   }
-}
+};
 
 const readCompileContextFile = ({ logger, compileContextJsonFileUrl }) => {
-  let compileContextFileContent
+  let compileContextFileContent;
   try {
-    compileContextFileContent = readFileSync(compileContextJsonFileUrl)
+    compileContextFileContent = readFileSync(compileContextJsonFileUrl);
   } catch (e) {
     logger.debug(
       `${UNICODE.INFO} cannot read compile context at ${compileContextJsonFileUrl}`,
-    )
-    return null
+    );
+    return null;
   }
   try {
-    const compileContext = JSON.parse(compileContextFileContent)
-    return compileContext
+    const compileContext = JSON.parse(compileContextFileContent);
+    return compileContext;
   } catch (e) {
     if (e.name === "SyntaxError") {
       logger.warn(
         `${UNICODE.WARN} syntax error in ${compileContextJsonFileUrl}`,
-      )
-      return null
+      );
+      return null;
     }
-    throw e
+    throw e;
   }
-}
+};
 
 const startAsap = async (fn, { compiledFileUrl }) => {
-  const unlockLocal = await lockForResource(compiledFileUrl)
+  const unlockLocal = await lockForResource(compiledFileUrl);
   try {
-    return await fn()
+    return await fn();
   } finally {
     // "finally" we want to unlock in case of error too
-    unlockLocal()
+    unlockLocal();
   }
-}
+};

package/src/compile_cache/file_lock_registry.js

@@ -1,24 +1,24 @@
 export const createLockRegistry = () => {
-  let lockArray = []
+  let lockArray = [];
   const lockForResource = async (resource) => {
-    const currentLock = lockArray.find((lock) => lock.resource === resource)
-    let unlockResolve
+    const currentLock = lockArray.find((lock) => lock.resource === resource);
+    let unlockResolve;
     const unlocked = new Promise((resolve) => {
-      unlockResolve = resolve
-    })
+      unlockResolve = resolve;
+    });
     const lock = {
       resource,
       unlocked,
-    }
-    lockArray = [...lockArray, lock]
+    };
+    lockArray = [...lockArray, lock];
 
-    if (currentLock) await currentLock.unlocked
+    if (currentLock) await currentLock.unlocked;
 
     const unlock = () => {
-      lockArray = lockArray.filter((lockCandidate) => lockCandidate !== lock)
-      unlockResolve()
-    }
-    return unlock
-  }
-  return { lockForResource }
-}
+      lockArray = lockArray.filter((lockCandidate) => lockCandidate !== lock);
+      unlockResolve();
+    };
+    return unlock;
+  };
+  return { lockForResource };
+};