@jsenv/core 40.3.1 → 40.3.3

package/src/kitchen/kitchen.js

@@ -20,10 +20,9 @@ import { createUrlGraph } from "./url_graph/url_graph.js";
 import { createUrlInfoTransformer } from "./url_graph/url_info_transformations.js";
 import { urlSpecifierEncoding } from "./url_graph/url_specifier_encoding.js";
 
-const inlineContentClientFileUrl = new URL(
+const inlineContentClientFileUrl = import.meta.resolve(
   "./client/inline_content.js",
-  import.meta.url,
-).href;
+);
 
 export const createKitchen = ({
   name,
@@ -32,12 +31,14 @@ export const createKitchen = ({
 
   rootDirectoryUrl,
   mainFilePath,
-  ignore,
-  ignoreProtocol = "remove",
-  supportedProtocols = ["file:", "data:", "virtual:", "http:", "https:"],
   dev = false,
   build = false,
   runtimeCompat,
+
+  ignore,
+  ignoreProtocol = "remove",
+  supportedProtocols = ["file:", "data:", "virtual:", "http:", "https:"],
+
   // during dev/test clientRuntimeCompat is a single runtime
   // during build clientRuntimeCompat is runtimeCompat
   clientRuntimeCompat = runtimeCompat,
@@ -50,12 +51,17 @@ export const createKitchen = ({
   outDirectoryUrl,
   initialContext = {},
   packageDirectory,
+  packageDependencies,
 }) => {
   const logger = createLogger({ logLevel });
 
   const nodeRuntimeEnabled = Object.keys(runtimeCompat).includes("node");
   const packageConditions = [nodeRuntimeEnabled ? "node" : "browser", "import"];
 
+  if (packageDependencies === "auto") {
+    packageDependencies = build && nodeRuntimeEnabled ? "ignore" : "include";
+  }
+
   const kitchen = {
     context: {
       ...initialContext,
@@ -125,6 +131,82 @@ export const createKitchen = ({
     const protocolIsSupported = supportedProtocols.includes(protocol);
     return !protocolIsSupported;
   };
+  const isIgnoredBecauseInPackageDependencies = (() => {
+    if (packageDependencies === undefined) {
+      return FUNCTION_RETURNING_FALSE;
+    }
+    if (packageDependencies === "include") {
+      return FUNCTION_RETURNING_FALSE;
+    }
+    if (!packageDirectory.url) {
+      return FUNCTION_RETURNING_FALSE;
+    }
+    const rootPackageJSON = packageDirectory.read(packageDirectory.url);
+    if (!rootPackageJSON) {
+      return FUNCTION_RETURNING_FALSE;
+    }
+    const { dependencies = {}, optionalDependencies = {} } = rootPackageJSON;
+    const dependencyKeys = Object.keys(dependencies);
+    const optionalDependencyKeys = Object.keys(optionalDependencies);
+    const dependencySet = new Set([
+      ...dependencyKeys,
+      ...optionalDependencyKeys,
+    ]);
+    if (dependencySet.size === 0) {
+      return FUNCTION_RETURNING_FALSE;
+    }
+
+    let getEffect;
+    if (packageDependencies === "ignore") {
+      getEffect = (dependencyName) => {
+        if (!dependencySet.has(dependencyName)) {
+          return "include";
+        }
+        return "ignore";
+      };
+    } else if (typeof packageDependencies === "object") {
+      let defaultEffect = "ignore";
+      const dependencyEffectMap = new Map();
+      for (const dependencyKey of Object.keys(packageDependencies)) {
+        const dependencyEffect = packageDependencies[dependencyKey];
+        if (dependencyKey === "*") {
+          defaultEffect = dependencyEffect;
+        } else {
+          dependencyEffectMap.set(dependencyKey, dependencyEffect);
+        }
+      }
+      getEffect = (dependencyName) => {
+        if (!dependencySet.has(dependencyName)) {
+          return "include";
+        }
+        const dependencyEffect = packageDependencies[dependencyName];
+        if (dependencyEffect) {
+          return dependencyEffect;
+        }
+        return defaultEffect;
+      };
+    }
+    return (url) => {
+      if (!url.startsWith("file:")) {
+        return false;
+      }
+      const packageDirectoryUrl = packageDirectory.find(url);
+      if (!packageDirectoryUrl) {
+        return false;
+      }
+      const packageJSON = packageDirectory.read(packageDirectoryUrl);
+      const name = packageJSON?.name;
+      if (!name) {
+        return false;
+      }
+      const effect = getEffect(name);
+      if (effect !== "ignore") {
+        return false;
+      }
+      return true;
+    };
+  })();
+
   let isIgnoredByParam = () => false;
   if (ignore) {
     const associations = URL_META.resolveAssociations(
@@ -144,7 +226,11 @@ export const createKitchen = ({
     };
   }
   const isIgnored = (url) => {
-    return isIgnoredByProtocol(url) || isIgnoredByParam(url);
+    return (
+      isIgnoredByProtocol(url) ||
+      isIgnoredByParam(url) ||
+      isIgnoredBecauseInPackageDependencies(url)
+    );
   };
   const resolveReference = (reference) => {
     const setReferenceUrl = (referenceUrl) => {
@@ -635,6 +721,8 @@ ${urlInfo.firstReference.trace.message}`;
   return kitchen;
 };
 
+const FUNCTION_RETURNING_FALSE = () => false;
+
 const debounceCook = (cook) => {
   const pendingDishes = new Map();
   return async (urlInfo, context) => {

package/src/plugins/package_side_effects/jsenv_plugin_package_side_effects.js

@@ -11,10 +11,8 @@
  *
  */
 
-import { updateJsonFileSync } from "@jsenv/filesystem";
 import { isSpecifierForNodeBuiltin } from "@jsenv/node-esm-resolution/src/node_builtin_specifiers.js";
 import { URL_META } from "@jsenv/url-meta";
-import { urlToRelativeUrl } from "@jsenv/urls";
 
 export const jsenvPluginPackageSideEffects = ({ packageDirectory }) => {
   if (!packageDirectory.url) {
@@ -29,19 +27,6 @@ export const jsenvPluginPackageSideEffects = ({ packageDirectory }) => {
     return [];
   }
 
-  const sideEffectFileUrlSet = new Set();
-  const packageJsonFileUrl = new URL("./package.json", packageDirectory.url)
-    .href;
-
-  const normalizeSideEffectFileUrl = (url) => {
-    const urlRelativeToPackage = urlToRelativeUrl(url, packageDirectory.url);
-    return urlRelativeToPackage[0] === "."
-      ? urlRelativeToPackage
-      : `./${urlRelativeToPackage}`;
-  };
-
-  const sideEffectBuildFileUrls = [];
-
   const packageSideEffectsCacheMap = new Map();
   const readSideEffectInfoFromClosestPackage = (urlInfo) => {
     const closestPackageDirectoryUrl = urlInfo.packageDirectoryUrl;
@@ -167,47 +152,16 @@ export const jsenvPluginPackageSideEffects = ({ packageDirectory }) => {
         return;
       }
     },
-    refineBuildUrlContent: (buildUrlInfo, { buildUrl }) => {
+    refineBuildUrlContent: (
+      buildUrlInfo,
+      { buildUrl, registerBuildSideEffectFile },
+    ) => {
       for (const sideEffect of buildUrlInfo.contentSideEffects) {
         if (sideEffect.has) {
-          sideEffectBuildFileUrls.push(buildUrl);
+          registerBuildSideEffectFile(buildUrl);
           return;
         }
       }
     },
-    refineBuild: () => {
-      if (sideEffectBuildFileUrls.length === 0) {
-        return;
-      }
-      let sideEffectsToAdd = [];
-      if (sideEffects === false) {
-        sideEffectsToAdd = sideEffectBuildFileUrls;
-      } else if (Array.isArray(sideEffects)) {
-        for (const sideEffectFileRelativeUrl of sideEffects) {
-          const sideEffectFileUrl = new URL(
-            sideEffectFileRelativeUrl,
-            packageDirectory.url,
-          ).href;
-          sideEffectFileUrlSet.add(sideEffectFileUrl);
-        }
-        for (const url of sideEffectBuildFileUrls) {
-          if (sideEffectFileUrlSet.has(url)) {
-            continue;
-          }
-          sideEffectsToAdd.push(url);
-        }
-      }
-      if (sideEffectsToAdd.length === 0) {
-        return;
-      }
-
-      const finalSideEffects = Array.isArray(sideEffects) ? sideEffects : [];
-      for (const sideEffectBuildUrl of sideEffectBuildFileUrls) {
-        finalSideEffects.push(normalizeSideEffectFileUrl(sideEffectBuildUrl));
-      }
-      updateJsonFileSync(packageJsonFileUrl, {
-        sideEffects: finalSideEffects,
-      });
-    },
   };
 };

package/dist/babel_helpers/AsyncGenerator/AsyncGenerator.js

@@ -1,112 +0,0 @@
-/* @minVersion 7.0.0-beta.0 */
-
-import OverloadYield from "../OverloadYield/OverloadYield.js";
-
-export default function AsyncGenerator(gen) {
-  var front, back;
-
-  function send(key, arg) {
-    return new Promise(function (resolve, reject) {
-      var request = {
-        key: key,
-        arg: arg,
-        resolve: resolve,
-        reject: reject,
-        next: null,
-      };
-
-      if (back) {
-        back = back.next = request;
-      } else {
-        front = back = request;
-        resume(key, arg);
-      }
-    });
-  }
-
-  function resume(key, arg) {
-    try {
-      var result = gen[key](arg);
-      var value = result.value;
-      var overloaded = value instanceof OverloadYield;
-
-      Promise.resolve(overloaded ? value.v : value).then(
-        function (arg) {
-          if (overloaded) {
-            // Overloaded yield requires calling into the generator twice:
-            //  - first we get the iterator result wrapped in a promise
-            //    (the gen[key](arg) call above)
-            //  - then we await it (the Promise.resolve call above)
-            //  - then we give the result back to the iterator, so that it can:
-            //    * if it was an await, use its result
-            //    * if it was a yield*, possibly return the `done: true` signal
-            //      so that yield* knows that the iterator is finished.
-            //      This needs to happen in the second call, because in the
-            //      first one `done: true` was hidden in the promise and thus
-            //      not visible to the (sync) yield*.
-            //      The other part of this implementation is in asyncGeneratorDelegate.
-            var nextKey = key === "return" ? "return" : "next";
-            if (!value.k || arg.done) {
-              // await or end of yield*
-              return resume(nextKey, arg);
-            } else {
-              // yield*, not done
-              arg = gen[nextKey](arg).value;
-            }
-          }
-
-          settle(result.done ? "return" : "normal", arg);
-        },
-        function (err) {
-          resume("throw", err);
-        },
-      );
-    } catch (err) {
-      settle("throw", err);
-    }
-  }
-
-  function settle(type, value) {
-    switch (type) {
-      case "return":
-        front.resolve({ value: value, done: true });
-        break;
-      case "throw":
-        front.reject(value);
-        break;
-      default:
-        front.resolve({ value: value, done: false });
-        break;
-    }
-
-    front = front.next;
-    if (front) {
-      resume(front.key, front.arg);
-    } else {
-      back = null;
-    }
-  }
-
-  this._invoke = send;
-
-  // Hide "return" method if generator return is not supported
-  if (typeof gen.return !== "function") {
-    this.return = undefined;
-  }
-}
-
-AsyncGenerator.prototype[
-  (typeof Symbol === "function" && Symbol.asyncIterator) || "@@asyncIterator"
-] = function () {
-  return this;
-};
-
-AsyncGenerator.prototype.next = function (arg) {
-  return this._invoke("next", arg);
-};
-AsyncGenerator.prototype.throw = function (arg) {
-  return this._invoke("throw", arg);
-};
-AsyncGenerator.prototype.return = function (arg) {
-  return this._invoke("return", arg);
-};

package/dist/babel_helpers/AwaitValue/AwaitValue.js

@@ -1,3 +0,0 @@
-export default function _AwaitValue(value) {
-  this.wrapped = value;
-}

package/dist/babel_helpers/OverloadYield/OverloadYield.js

@@ -1,11 +0,0 @@
-/* @minVersion 7.18.14 */
-
-/*
- * 'kind' is an enum:
- *   0 => This yield was an await expression
- *   1 => This yield comes from yield*
- */
-export default function _OverloadYield(value, kind) {
-  this.v = value;
-  this.k = kind;
-}

package/dist/babel_helpers/applyDecoratedDescriptor/applyDecoratedDescriptor.js

@@ -1,32 +0,0 @@
-export default function _applyDecoratedDescriptor(
-  target,
-  property,
-  decorators,
-  descriptor,
-  context,
-) {
-  var desc = {};
-  Object.keys(descriptor).forEach(function (key) {
-    desc[key] = descriptor[key];
-  });
-  desc.enumerable = !!desc.enumerable;
-  desc.configurable = !!desc.configurable;
-  if ("value" in desc || desc.initializer) {
-    desc.writable = true;
-  }
-  desc = decorators
-    .slice()
-    .reverse()
-    .reduce(function (desc, decorator) {
-      return decorator(target, property, desc) || desc;
-    }, desc);
-  if (context && desc.initializer !== void 0) {
-    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
-    desc.initializer = undefined;
-  }
-  if (desc.initializer === void 0) {
-    Object.defineProperty(target, property, desc);
-    desc = null;
-  }
-  return desc;
-}