@jsenv/plugin-commonjs 2.0.5 → 2.0.6

package/src/compile_cache/update_compile_cache.js

@@ -1,7 +1,7 @@
-import { existsSync, utimesSync } from "node:fs"
-import { fileURLToPath } from "node:url"
-import { urlToRelativeUrl } from "@jsenv/urls"
-import { writeFileSync, bufferToEtag } from "@jsenv/filesystem"
+import { existsSync, utimesSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { urlToRelativeUrl } from "@jsenv/urls";
+import { writeFileSync, bufferToEtag } from "@jsenv/filesystem";
 
 export const updateCompileCache = ({
   logger,
@@ -11,60 +11,60 @@ export const updateCompileCache = ({
   mtime,
   compileResultStatus,
 }) => {
-  const isNew = compileResultStatus === "created"
-  const isUpdated = compileResultStatus === "updated"
+  const isNew = compileResultStatus === "created";
+  const isUpdated = compileResultStatus === "updated";
   if (!isNew && !isUpdated) {
-    return
+    return;
   }
 
   // ensure source that does not leads to files are not capable to invalidate the cache
-  const filesRemoved = []
+  const filesRemoved = [];
   Object.keys(assets).forEach((assetUrl) => {
     if (
       assetUrl.startsWith("file://") &&
       assets[assetUrl].type === "source" &&
       !existsSync(new URL(assetUrl))
     ) {
-      delete assets[assetUrl]
-      filesRemoved.push(assetUrl)
+      delete assets[assetUrl];
+      filesRemoved.push(assetUrl);
     }
-  })
-  const notFoundCount = filesRemoved.length
+  });
+  const notFoundCount = filesRemoved.length;
   if (notFoundCount > 0) {
     logger.warn(`COMPILE_ASSET_FILE_NOT_FOUND: ${notFoundCount} file(s) not found.
 --- consequence ---
 cache will be reused even if one of the source file is modified
 --- files not found ---
-${filesRemoved.join(`\n`)}`)
+${filesRemoved.join(`\n`)}`);
   }
 
-  logger.debug(`write compiled file at ${fileURLToPath(compiledFileUrl)}`)
+  logger.debug(`write compiled file at ${fileURLToPath(compiledFileUrl)}`);
   writeFileSync(compiledFileUrl, content, {
     fileLikelyNotFound: isNew,
-  })
+  });
   // mtime is passed, it meant the file mtime is important
   // -> we update file mtime
   if (mtime) {
-    utimesSync(new URL(compiledFileUrl), new Date(mtime), new Date(mtime))
+    utimesSync(new URL(compiledFileUrl), new Date(mtime), new Date(mtime));
   }
 
-  const assetInfos = {}
+  const assetInfos = {};
   Object.keys(assets).forEach((assetUrl) => {
-    logger.debug(`write compiled file asset at ${fileURLToPath(assetUrl)}`)
-    const asset = assets[assetUrl]
+    logger.debug(`write compiled file asset at ${fileURLToPath(assetUrl)}`);
+    const asset = assets[assetUrl];
     writeFileSync(assetUrl, asset.content, {
       fileLikelyNotFound: isNew,
-    })
-    const assetRelativeUrl = urlToRelativeUrl(assetUrl, compiledFileUrl)
-    const assetEtag = asset.etag || bufferToEtag(Buffer.from(asset.content))
+    });
+    const assetRelativeUrl = urlToRelativeUrl(assetUrl, compiledFileUrl);
+    const assetEtag = asset.etag || bufferToEtag(Buffer.from(asset.content));
     assetInfos[assetRelativeUrl] = {
       type: asset.type,
       etag: assetEtag,
-    }
-  })
+    };
+  });
 
-  const compileInfoFileUrl = `${compiledFileUrl}__compile_info__.json`
-  let latestCompileInfo
+  const compileInfoFileUrl = `${compiledFileUrl}__compile_info__.json`;
+  let latestCompileInfo;
   if (isNew) {
     latestCompileInfo = {
       // was used at some point to ensure the compiled file matches browser etag
@@ -72,23 +72,23 @@ ${filesRemoved.join(`\n`)}`)
       assetInfos,
       createdMs: Date.now(),
       lastModifiedMs: Date.now(),
-    }
+    };
   } else if (isUpdated) {
     latestCompileInfo = {
       // was used at some point to ensure the compiled file matches browser etag
       // etag: bufferToEtag(Buffer.from(content)),
       assetInfos,
       lastModifiedMs: Date.now(),
-    }
+    };
   }
   logger.debug(
     `write compiled file info at ${fileURLToPath(compileInfoFileUrl)}`,
-  )
+  );
   writeFileSync(
     compileInfoFileUrl,
     JSON.stringify(latestCompileInfo, null, "  "),
     {
       fileLikelyNotFound: isNew,
     },
-  )
-}
+  );
+};

package/src/compile_cache/validate_compile_cache.js

@@ -1,78 +1,78 @@
-import { readFileSync, statSync } from "node:fs"
-import { bufferToEtag } from "@jsenv/filesystem"
+import { readFileSync, statSync } from "node:fs";
+import { bufferToEtag } from "@jsenv/filesystem";
 
 export const validateCompileCache = ({
   compiledFileUrl,
   compileCacheStrategy,
   compileCacheAssetsValidation = true,
 }) => {
-  const validity = { isValid: true }
+  const validity = { isValid: true };
   const compileInfoValidity = validateCompileInfoFile({
     compiledFileUrl,
-  })
-  validity.compileInfo = compileInfoValidity
-  mergeValidity(validity, compileInfoValidity)
+  });
+  validity.compileInfo = compileInfoValidity;
+  mergeValidity(validity, compileInfoValidity);
   if (!validity.isValid) {
-    return validity
+    return validity;
   }
   const compiledFileValidity = validateCompiledFile({
     compiledFileUrl,
     compileCacheStrategy,
-  })
-  validity.compiledFile = compiledFileValidity
-  mergeValidity(validity, compiledFileValidity)
+  });
+  validity.compiledFile = compiledFileValidity;
+  mergeValidity(validity, compiledFileValidity);
   if (!validity.isValid) {
-    return validity
+    return validity;
   }
-  const compileInfo = compileInfoValidity.data
+  const compileInfo = compileInfoValidity.data;
   const assetsValidity = compileCacheAssetsValidation
     ? validateAssets({
         compiledFileUrl,
         compileInfo,
       })
-    : { isValid: true, code: "ASSETS_VALIDATION_DISABLED" }
-  validity.assets = assetsValidity
-  mergeValidity(validity, assetsValidity)
+    : { isValid: true, code: "ASSETS_VALIDATION_DISABLED" };
+  validity.assets = assetsValidity;
+  mergeValidity(validity, assetsValidity);
   if (!validity.isValid) {
-    return validity
+    return validity;
   }
-  return validity
-}
+  return validity;
+};
 
 const validateCompileInfoFile = ({ compiledFileUrl }) => {
-  const compileInfoFileUrl = `${compiledFileUrl}__compile_info__.json`
-  const validity = { isValid: true, data: {} }
-  let compileInfoFileContentAsBuffer
+  const compileInfoFileUrl = `${compiledFileUrl}__compile_info__.json`;
+  const validity = { isValid: true, data: {} };
+  let compileInfoFileContentAsBuffer;
   try {
-    compileInfoFileContentAsBuffer = readFileSync(new URL(compileInfoFileUrl))
+    compileInfoFileContentAsBuffer = readFileSync(new URL(compileInfoFileUrl));
   } catch (error) {
     if (error && error.code === "ENOENT") {
-      validity.isValid = false
-      validity.code = "COMPILE_INFO_FILE_NOT_FOUND"
-      return validity
+      validity.isValid = false;
+      validity.code = "COMPILE_INFO_FILE_NOT_FOUND";
+      return validity;
     }
-    throw error
+    throw error;
   }
-  const compileInfoFileContentAsString = String(compileInfoFileContentAsBuffer)
-  let compileInfo
+  const compileInfoFileContentAsString = String(compileInfoFileContentAsBuffer);
+  let compileInfo;
   try {
-    compileInfo = JSON.parse(compileInfoFileContentAsString)
+    compileInfo = JSON.parse(compileInfoFileContentAsString);
   } catch (error) {
     if (error && error.name === "SyntaxError") {
-      validity.isValid = false
-      validity.code = "COMPILE_INFO_FILE_SYNTAX_ERROR"
-      return validity
+      validity.isValid = false;
+      validity.code = "COMPILE_INFO_FILE_SYNTAX_ERROR";
+      return validity;
     }
-    throw error
+    throw error;
   }
-  validity.data = compileInfo
+  validity.data = compileInfo;
   if (Object.keys(compileInfo.assetInfos).length === 0) {
-    validity.isValid = false
-    validity.code = "ASSETS_EMPTY"
-    return validity
+    validity.isValid = false;
+    validity.code = "ASSETS_EMPTY";
+    return validity;
   }
-  return validity
-}
+  return validity;
+};
 
 const validateCompiledFile = ({
   compiledFileUrl,
@@ -80,28 +80,28 @@ const validateCompiledFile = ({
   lastEtag,
   lastModificationTime,
 }) => {
-  const validity = { isValid: true, data: {} }
+  const validity = { isValid: true, data: {} };
   try {
-    const buffer = readFileSync(new URL(compiledFileUrl))
-    validity.data.buffer = buffer
+    const buffer = readFileSync(new URL(compiledFileUrl));
+    validity.data.buffer = buffer;
     if (compileCacheStrategy === "etag" && lastEtag) {
-      const etag = bufferToEtag(buffer)
-      validity.data.etag = etag
+      const etag = bufferToEtag(buffer);
+      validity.data.etag = etag;
       if (lastEtag && lastEtag !== etag) {
-        validity.isValid = false
-        validity.code = "COMPILED_FILE_ETAG_MISMATCH"
-        return validity
+        validity.isValid = false;
+        validity.code = "COMPILED_FILE_ETAG_MISMATCH";
+        return validity;
       }
     }
     if (compileCacheStrategy === "mtime" && lastModificationTime) {
-      const stats = statSync(new URL(compiledFileUrl))
-      const mtime = Math.floor(stats.mtimeMs)
-      validity.data.mtime = mtime
-      let ifModifiedSinceDate
+      const stats = statSync(new URL(compiledFileUrl));
+      const mtime = Math.floor(stats.mtimeMs);
+      validity.data.mtime = mtime;
+      let ifModifiedSinceDate;
       try {
-        ifModifiedSinceDate = new Date(lastModificationTime)
+        ifModifiedSinceDate = new Date(lastModificationTime);
       } catch (e) {
-        ifModifiedSinceDate = null
+        ifModifiedSinceDate = null;
         // ideally we should rather respond with
         // 400 "if-modified-since header is not a valid date"
       }
@@ -109,63 +109,63 @@ const validateCompiledFile = ({
         ifModifiedSinceDate &&
         ifModifiedSinceDate < dateToSecondsPrecision(mtime)
       ) {
-        validity.isValid = false
-        validity.code = "COMPILED_FILE_MTIME_OUTDATED"
-        return validity
+        validity.isValid = false;
+        validity.code = "COMPILED_FILE_MTIME_OUTDATED";
+        return validity;
       }
     }
-    return validity
+    return validity;
   } catch (error) {
     if (error && error.code === "ENOENT") {
-      validity.isValid = false
-      validity.code = "COMPILED_FILE_NOT_FOUND"
-      return validity
+      validity.isValid = false;
+      validity.code = "COMPILED_FILE_NOT_FOUND";
+      return validity;
     }
-    throw error
+    throw error;
   }
-}
+};
 
 const validateAssets = ({ compiledFileUrl, compileInfo }) => {
-  const assetsValidity = { isValid: true, data: {} }
+  const assetsValidity = { isValid: true, data: {} };
 
-  const assetRelativeUrls = Object.keys(compileInfo.assetInfos)
+  const assetRelativeUrls = Object.keys(compileInfo.assetInfos);
   for (const assetRelativeUrl of assetRelativeUrls) {
-    const assetInfo = compileInfo.assetInfos[assetRelativeUrl]
-    const assetUrl = new URL(assetRelativeUrl, compiledFileUrl).href
-    const assetValidity = { isValid: true, data: {} }
+    const assetInfo = compileInfo.assetInfos[assetRelativeUrl];
+    const assetUrl = new URL(assetRelativeUrl, compiledFileUrl).href;
+    const assetValidity = { isValid: true, data: {} };
     if (assetInfo.type === "source") {
       validateSource(assetValidity, {
         sourceFileUrl: assetUrl,
         eTag: assetInfo.etag,
-      })
+      });
     }
     if (assetInfo.type === "sourcemap") {
       validateSourcemap(assetValidity, {
         sourcemapFileUrl: assetUrl,
-      })
+      });
     }
-    assetsValidity.data[assetUrl] = assetValidity
-    mergeValidity(assetsValidity, assetValidity)
+    assetsValidity.data[assetUrl] = assetValidity;
+    mergeValidity(assetsValidity, assetValidity);
     if (!assetsValidity.isValid) {
-      break
+      break;
     }
   }
 
-  return assetsValidity
-}
+  return assetsValidity;
+};
 
 const validateSource = (validity, { sourceFileUrl, eTag }) => {
   try {
-    const sourceBuffer = readFileSync(new URL(sourceFileUrl))
-    const sourceETag = bufferToEtag(sourceBuffer)
-    validity.data.content = String(sourceBuffer)
-    validity.data.etag = sourceETag
+    const sourceBuffer = readFileSync(new URL(sourceFileUrl));
+    const sourceETag = bufferToEtag(sourceBuffer);
+    validity.data.content = String(sourceBuffer);
+    validity.data.etag = sourceETag;
     if (sourceETag !== eTag) {
-      validity.isValid = false
-      validity.code = "SOURCE_ETAG_MISMATCH"
-      return validity
+      validity.isValid = false;
+      validity.code = "SOURCE_ETAG_MISMATCH";
+      return validity;
     }
-    return validity
+    return validity;
   } catch (e) {
     if (e && e.code === "ENOENT") {
       // missing source invalidates the cache because
@@ -177,50 +177,50 @@ const validateSource = (validity, { sourceFileUrl, eTag }) => {
       // which are not truly on the filesystem
       // (IN theory the above happens only for convertCommonJsWithRollup because jsenv
       // always have a concrete file especially to avoid that kind of thing)
-      validity.isValid = false
-      validity.code = "SOURCE_NOT_FOUND"
-      return validity
+      validity.isValid = false;
+      validity.code = "SOURCE_NOT_FOUND";
+      return validity;
     }
-    throw e
+    throw e;
   }
-}
+};
 
 const validateSourcemap = (validity, { sourcemapFileUrl }) => {
-  let sourcemapFileContentAsBuffer
+  let sourcemapFileContentAsBuffer;
   try {
-    sourcemapFileContentAsBuffer = readFileSync(new URL(sourcemapFileUrl))
+    sourcemapFileContentAsBuffer = readFileSync(new URL(sourcemapFileUrl));
   } catch (error) {
     if (error && error.code === "ENOENT") {
-      validity.isValid = false
-      validity.code = "SOURCEMAP_FILE_NOT_FOUND"
-      return validity
+      validity.isValid = false;
+      validity.code = "SOURCEMAP_FILE_NOT_FOUND";
+      return validity;
     }
-    throw error
+    throw error;
   }
-  const sourcemapFileContentAsString = String(sourcemapFileContentAsBuffer)
-  validity.data.content = sourcemapFileContentAsString
-  let sourcemap
+  const sourcemapFileContentAsString = String(sourcemapFileContentAsBuffer);
+  validity.data.content = sourcemapFileContentAsString;
+  let sourcemap;
   try {
-    sourcemap = JSON.parse(sourcemapFileContentAsString)
+    sourcemap = JSON.parse(sourcemapFileContentAsString);
   } catch (error) {
     if (error && error.name === "SyntaxError") {
-      validity.isValid = false
-      validity.code = "SOURCEMAP_FILE_SYNTAX_ERROR"
-      return validity
+      validity.isValid = false;
+      validity.code = "SOURCEMAP_FILE_SYNTAX_ERROR";
+      return validity;
     }
-    throw error
+    throw error;
   }
-  validity.data.sourcemap = sourcemap
-  return validity
-}
+  validity.data.sourcemap = sourcemap;
+  return validity;
+};
 
 const mergeValidity = (parentValidity, childValidity) => {
-  parentValidity.isValid = childValidity.isValid
-  if (childValidity.code) parentValidity.code = childValidity.code
-}
+  parentValidity.isValid = childValidity.isValid;
+  if (childValidity.code) parentValidity.code = childValidity.code;
+};
 
 const dateToSecondsPrecision = (date) => {
-  const dateWithSecondsPrecision = new Date(date)
-  dateWithSecondsPrecision.setMilliseconds(0)
-  return dateWithSecondsPrecision
-}
+  const dateWithSecondsPrecision = new Date(date);
+  dateWithSecondsPrecision.setMilliseconds(0);
+  return dateWithSecondsPrecision;
+};

package/src/jsenv_plugin_commonjs.js

@@ -1,10 +1,10 @@
-import { URL_META } from "@jsenv/url-meta"
-import { injectQueryParams, urlToExtension } from "@jsenv/urls"
-import { defaultLookupPackageScope } from "@jsenv/node-esm-resolution"
+import { URL_META } from "@jsenv/url-meta";
+import { injectQueryParams, urlToExtension } from "@jsenv/urls";
+import { defaultLookupPackageScope } from "@jsenv/node-esm-resolution";
 
-import { commonJsToJsModule } from "./cjs_to_esm.js"
+import { commonJsToJsModule } from "./cjs_to_esm.js";
 
-const compileCacheDirectoryUrl = new URL("../.cache/", import.meta.url)
+const compileCacheDirectoryUrl = new URL("../.cache/", import.meta.url);
 
 export const jsenvPluginCommonJs = ({
   name = "jsenv:commonjs",
@@ -12,23 +12,23 @@ export const jsenvPluginCommonJs = ({
   include,
 }) => {
   const markAsJsModuleProxy = (reference) => {
-    reference.expectedType = "js_module"
-    const packageFileUrl = defaultLookupPackageScope(reference.url)
+    reference.expectedType = "js_module";
+    const packageFileUrl = defaultLookupPackageScope(reference.url);
     if (packageFileUrl) {
       reference.filename = `${reference.specifier}${urlToExtension(
         reference.parentUrl,
-      )}`
+      )}`;
     }
-  }
+  };
   const turnIntoJsModuleProxy = (reference) => {
     const urlTransformed = injectQueryParams(reference.url, {
       cjs_as_js_module: "",
-    })
-    markAsJsModuleProxy(reference)
-    return urlTransformed
-  }
+    });
+    markAsJsModuleProxy(reference);
+    return urlTransformed;
+  };
 
-  let associations
+  let associations;
 
   return {
     name,
@@ -39,22 +39,22 @@ export const jsenvPluginCommonJs = ({
           commonjs: include,
         },
         rootDirectoryUrl,
-      )
+      );
     },
-    redirectUrl: (reference) => {
+    redirectReference: (reference) => {
       if (reference.searchParams.has("cjs_as_js_module")) {
-        markAsJsModuleProxy(reference)
-        return null
+        markAsJsModuleProxy(reference);
+        return null;
       }
       const { commonjs } = URL_META.applyAssociations({
         url: reference.url,
         associations,
-      })
+      });
       if (!commonjs) {
-        return null
+        return null;
       }
-      reference.data.commonjs = commonjs
-      return turnIntoJsModuleProxy(reference)
+      reference.data.commonjs = commonjs;
+      return turnIntoJsModuleProxy(reference);
     },
     fetchUrlContent: async (urlInfo, context) => {
       const [commonJsReference, commonJsUrlInfo] =
@@ -65,16 +65,16 @@ export const jsenvPluginCommonJs = ({
           // during this fetch we don't want to alter the original file
           // so we consider it as text
           expectedType: "text",
-        })
+        });
       if (!commonJsReference) {
-        return null
+        return null;
       }
       await context.fetchUrlContent(commonJsUrlInfo, {
         reference: commonJsReference,
-      })
+      });
       const nodeRuntimeEnabled = Object.keys(context.runtimeCompat).includes(
         "node",
-      )
+      );
       const { content, sourcemap, isValid } = await commonJsToJsModule({
         logLevel,
         compileCacheDirectoryUrl,
@@ -82,9 +82,9 @@ export const jsenvPluginCommonJs = ({
         browsers: !nodeRuntimeEnabled,
         processEnvNodeEnv: context.dev ? "development" : "production",
         ...urlInfo.data.commonjs,
-      })
+      });
       if (isValid) {
-        urlInfo.isValid = isValid
+        urlInfo.isValid = isValid;
       }
       return {
         content,
@@ -94,7 +94,7 @@ export const jsenvPluginCommonJs = ({
         originalContent: commonJsUrlInfo.originalContent,
         sourcemap,
         data: commonJsUrlInfo.data,
-      }
+      };
     },
-  }
-}
+  };
+};

package/src/main.js

@@ -1,2 +1,2 @@
-export { jsenvPluginCommonJs } from "./jsenv_plugin_commonjs.js"
-export { commonJsToJsModule } from "./cjs_to_esm.js"
+export { jsenvPluginCommonJs } from "./jsenv_plugin_commonjs.js";
+export { commonJsToJsModule } from "./cjs_to_esm.js";