@jsenv/plugin-as-js-classic 1.2.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/plugin-as-js-classic",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -24,8 +24,8 @@
     "test": "node --conditions=development ./scripts/test.mjs"
   },
   "dependencies": {
-    "@jsenv/urls": "2.0.0",
-    "@jsenv/js-module-fallback": "1.1.0",
-    "@jsenv/plugin-bundling": "2.2.0"
+    "@jsenv/urls": "2.1.0",
+    "@jsenv/js-module-fallback": "1.2.0",
+    "@jsenv/plugin-bundling": "2.3.0"
   }
 }

package/src/jsenv_plugin_as_js_classic.js

@@ -5,12 +5,12 @@ import {
 } from "@jsenv/js-module-fallback";
 import { bundleJsModules } from "@jsenv/plugin-bundling";
 
-import { createUrlGraphLoader } from "./url_graph_loader.js";
-
 export const jsenvPluginAsJsClassic = () => {
   const markAsJsClassicProxy = (reference) => {
     reference.expectedType = "js_classic";
-    reference.filename = generateJsClassicFilename(reference.url);
+    if (!reference.filename) {
+      reference.filename = generateJsClassicFilename(reference.url);
+    }
   };
 
   return {
@@ -21,36 +21,26 @@ export const jsenvPluginAsJsClassic = () => {
         markAsJsClassicProxy(reference);
       }
     },
-    fetchUrlContent: async (urlInfo, context) => {
-      const [jsModuleReference, jsModuleUrlInfo] =
-        context.getWithoutSearchParam({
-          urlInfo,
-          context,
-          searchParam: "as_js_classic",
-          // override the expectedType to "js_module"
-          // because when there is ?as_js_classic it means the underlying resource
-          // is a js_module
-          expectedType: "js_module",
-        });
-      if (!jsModuleReference) {
+    fetchUrlContent: async (urlInfo) => {
+      const jsModuleUrlInfo = urlInfo.getWithoutSearchParam("as_js_classic", {
+        // override the expectedType to "js_module"
+        // because when there is ?as_js_classic it means the underlying resource
+        // is a js_module
+        expectedType: "js_module",
+      });
+      if (!jsModuleUrlInfo) {
         return null;
       }
       // cook it to get content + dependencies
-      await context.cook(jsModuleUrlInfo, { reference: jsModuleReference });
-      const loader = createUrlGraphLoader(context);
-      loader.loadReferencedUrlInfos(jsModuleUrlInfo, {
+      await jsModuleUrlInfo.cook();
+      await jsModuleUrlInfo.cookDependencies({
         // we ignore dynamic import to cook lazyly (as browser request the server)
         // these dynamic imports must inherit "?as_js_classic"
         // This is done inside rollup for convenience
         ignoreDynamicImport: true,
       });
-      await loader.getAllLoadDonePromise();
-      const bundleUrlInfos = await bundleJsModules({
-        jsModuleUrlInfos: [jsModuleUrlInfo],
-        context: {
-          ...context,
-          buildDirectoryUrl: new URL("./", import.meta.url),
-        },
+      const bundleUrlInfos = await bundleJsModules([jsModuleUrlInfo], {
+        buildDirectoryUrl: new URL("./", import.meta.url),
         preserveDynamicImport: true,
         augmentDynamicImportUrlSearchParams: () => {
           return {
@@ -60,47 +50,53 @@ export const jsenvPluginAsJsClassic = () => {
         },
       });
       const jsModuleBundledUrlInfo = bundleUrlInfos[jsModuleUrlInfo.url];
-      if (context.dev) {
-        jsModuleBundledUrlInfo.sourceUrls.forEach((sourceUrl) => {
-          context.referenceUtils.inject({
-            type: "js_url",
-            specifier: sourceUrl,
-            isImplicit: true,
-          });
-        });
-      } else if (context.build) {
-        jsModuleBundledUrlInfo.sourceUrls.forEach((sourceUrl) => {
-          const sourceUrlInfo = context.urlGraph.getUrlInfo(sourceUrl);
-          if (sourceUrlInfo && !context.urlGraph.hasDependent(sourceUrlInfo)) {
-            context.urlGraph.deleteUrlInfo(sourceUrl);
-          }
-        });
-      }
 
       let outputFormat;
-      if (urlInfo.isEntryPoint && !jsModuleBundledUrlInfo.data.usesImport) {
-        // if it's an entry point without dependency (it does not use import)
-        // then we can use UMD
-        outputFormat = "umd";
-      } else {
-        // otherwise we have to use system in case it's imported
-        // by an other file (for entry points)
-        // or to be able to import when it uses import
+      // if imported by js, we have to use systemjs
+      // or if import things
+      if (jsModuleBundledUrlInfo.data.usesImport || isImportedByJs(urlInfo)) {
+        // we have to use system when it uses import
         outputFormat = "system";
         urlInfo.type = "js_classic";
-        context.referenceUtils.foundSideEffectFile({
+        urlInfo.dependencies.foundSideEffectFile({
           sideEffectFileUrl: systemJsClientFileUrlDefault,
           expectedType: "js_classic",
           line: 0,
           column: 0,
         });
+      } else {
+        // if there is no dependency (it does not use import)
+        // then we can use UMD
+        outputFormat = "umd";
       }
+
+      if (urlInfo.context.dev) {
+        jsModuleBundledUrlInfo.sourceUrls.forEach((sourceUrl) => {
+          urlInfo.dependencies.inject({
+            isImplicit: true,
+            type: "js_url",
+            specifier: sourceUrl,
+          });
+        });
+      } else if (urlInfo.context.build) {
+        jsModuleUrlInfo.firstReference.remove();
+        jsModuleBundledUrlInfo.sourceUrls.forEach((sourceUrl) => {
+          const sourceUrlInfo = urlInfo.graph.getUrlInfo(sourceUrl);
+          if (
+            sourceUrlInfo &&
+            !sourceUrlInfo.getFirstReferenceFromOther({ ignoreWeak: true })
+          ) {
+            sourceUrlInfo.deleteFromGraph();
+          }
+        });
+      }
+
       const { content, sourcemap } = await convertJsModuleToJsClassic({
-        rootDirectoryUrl: context.rootDirectoryUrl,
+        rootDirectoryUrl: urlInfo.context.rootDirectoryUrl,
         input: jsModuleBundledUrlInfo.content,
         inputSourcemap: jsModuleBundledUrlInfo.sourcemap,
-        inputUrl: jsModuleBundledUrlInfo.url,
-        outputUrl: jsModuleBundledUrlInfo.generatedUrl,
+        inputUrl: urlInfo.url,
+        outputUrl: jsModuleBundledUrlInfo.url,
         outputFormat,
       });
       return {
@@ -116,6 +112,19 @@ export const jsenvPluginAsJsClassic = () => {
   };
 };
 
+const isImportedByJs = (jsModuleUrlInfo) => {
+  for (const referenceFromOther of jsModuleUrlInfo.referenceFromOthersSet) {
+    const urlInfoReferencingJsModule = referenceFromOther.ownerUrlInfo;
+    if (
+      urlInfoReferencingJsModule.type === "js_module" ||
+      urlInfoReferencingJsModule.type === "js_classic"
+    ) {
+      return true;
+    }
+  }
+  return false;
+};
+
 const generateJsClassicFilename = (url) => {
   const filename = urlToFilename(url);
   let [basename, extension] = splitFileExtension(filename);

package/src/url_graph_loader.js

@@ -1,79 +0,0 @@
-// copy pasted from @jsenv/core to avoid dependency
-
-export const createUrlGraphLoader = (context) => {
-  const promises = [];
-  const promiseMap = new Map();
-  const load = (
-    urlInfo,
-    dishContext,
-    { ignoreRessourceHint = true, ignoreDynamicImport = false } = {},
-  ) => {
-    const promiseFromData = promiseMap.get(urlInfo);
-    if (promiseFromData) return promiseFromData;
-    const promise = (async () => {
-      await context.cook(urlInfo, {
-        cookDuringCook: load,
-        ...dishContext,
-      });
-      loadReferencedUrlInfos(urlInfo, {
-        ignoreRessourceHint,
-        ignoreDynamicImport,
-      });
-    })();
-    promises.push(promise);
-    promiseMap.set(urlInfo, promise);
-    return promise;
-  };
-
-  const loadReferencedUrlInfos = (
-    urlInfo,
-    { ignoreRessourceHint, ignoreDynamicImport },
-  ) => {
-    const { references } = urlInfo;
-    references.forEach((reference) => {
-      // we don't cook resource hints
-      // because they might refer to resource that will be modified during build
-      // It also means something else have to reference that url in order to cook it
-      // so that the preload is deleted by "resync_resource_hints.js" otherwise
-      if (ignoreRessourceHint && reference.isResourceHint) {
-        return;
-      }
-      if (ignoreDynamicImport && reference.subtype === "import_dynamic") {
-        return;
-      }
-      // we use reference.generatedUrl to mimic what a browser would do:
-      // do a fetch to the specifier as found in the file
-      const referencedUrlInfo = context.urlGraph.reuseOrCreateUrlInfo(
-        reference.generatedUrl,
-      );
-      load(referencedUrlInfo, {
-        reference,
-        ignoreRessourceHint,
-        ignoreDynamicImport,
-      });
-    });
-  };
-
-  const getAllLoadDonePromise = async (operation) => {
-    const waitAll = async () => {
-      if (operation) {
-        operation.throwIfAborted();
-      }
-      if (promises.length === 0) {
-        return;
-      }
-      const promisesToWait = promises.slice();
-      promises.length = 0;
-      await Promise.all(promisesToWait);
-      await waitAll();
-    };
-    await waitAll();
-    promiseMap.clear();
-  };
-
-  return {
-    load,
-    loadReferencedUrlInfos,
-    getAllLoadDonePromise,
-  };
-};