@jsenv/core 35.0.2 → 35.0.4

package/src/plugins/transpilation/import_assertions/jsenv_plugin_import_assertions.js

@@ -10,58 +10,58 @@
  * But for now (as it is simpler) we let the browser throw the error
  */
 
-import { urlToFilename, injectQueryParams } from "@jsenv/urls"
+import { urlToFilename, injectQueryParams } from "@jsenv/urls";
 
-import { JS_QUOTES } from "@jsenv/utils/src/string/js_quotes.js"
+import { JS_QUOTES } from "@jsenv/utils/src/string/js_quotes.js";
 
 export const jsenvPluginImportAssertions = ({
   json = "auto",
   css = "auto",
   text = "auto",
 }) => {
-  const transpilations = { json, css, text }
+  const transpilations = { json, css, text };
   const shouldTranspileImportAssertion = (context, type) => {
-    const transpilation = transpilations[type]
+    const transpilation = transpilations[type];
     if (transpilation === true) {
-      return true
+      return true;
     }
     if (transpilation === "auto") {
-      return !context.isSupportedOnCurrentClients(`import_type_${type}`)
+      return !context.isSupportedOnCurrentClients(`import_type_${type}`);
     }
-    return false
-  }
+    return false;
+  };
   const markAsJsModuleProxy = (reference) => {
-    reference.expectedType = "js_module"
-    reference.filename = `${urlToFilename(reference.url)}.js`
-  }
+    reference.expectedType = "js_module";
+    reference.filename = `${urlToFilename(reference.url)}.js`;
+  };
   const turnIntoJsModuleProxy = (reference, type) => {
     reference.mutation = (magicSource) => {
-      const { assertNode } = reference
+      const { assertNode } = reference;
       if (reference.subtype === "import_dynamic") {
         const assertPropertyNode = assertNode.properties.find(
           (prop) => prop.key.name === "assert",
-        )
-        const assertPropertyValue = assertPropertyNode.value
+        );
+        const assertPropertyValue = assertPropertyNode.value;
         const typePropertyNode = assertPropertyValue.properties.find(
           (prop) => prop.key.name === "type",
-        )
+        );
         magicSource.remove({
           start: typePropertyNode.start,
           end: typePropertyNode.end,
-        })
+        });
       } else {
         magicSource.remove({
           start: assertNode.start,
           end: assertNode.end,
-        })
+        });
       }
-    }
+    };
     const newUrl = injectQueryParams(reference.url, {
       [`as_${type}_module`]: "",
-    })
-    markAsJsModuleProxy(reference)
-    return newUrl
-  }
+    });
+    markAsJsModuleProxy(reference);
+    return newUrl;
+  };
 
   const importAssertions = {
     name: "jsenv:import_assertions",
@@ -73,39 +73,39 @@ export const jsenvPluginImportAssertions = ({
       //   - means rollup can bundle more js file together
       //   - means url versioning can work for css inlined in js
       if (context.build) {
-        transpilations.json = true
-        transpilations.css = true
-        transpilations.text = true
+        transpilations.json = true;
+        transpilations.css = true;
+        transpilations.text = true;
       }
     },
     redirectUrl: (reference, context) => {
       if (!reference.assert) {
-        return null
+        return null;
       }
-      const { searchParams } = reference
+      const { searchParams } = reference;
       if (
         searchParams.has("as_json_module") ||
         searchParams.has("as_css_module") ||
         searchParams.has("as_text_module")
       ) {
-        markAsJsModuleProxy(reference)
-        return null
+        markAsJsModuleProxy(reference);
+        return null;
       }
-      const type = reference.assert.type
+      const type = reference.assert.type;
       if (shouldTranspileImportAssertion(context, type)) {
-        return turnIntoJsModuleProxy(reference, type)
+        return turnIntoJsModuleProxy(reference, type);
       }
-      return null
+      return null;
     },
-  }
-  return [importAssertions, ...jsenvPluginAsModules()]
-}
+  };
+  return [importAssertions, ...jsenvPluginAsModules()];
+};
 
 const jsenvPluginAsModules = () => {
   const inlineContentClientFileUrl = new URL(
     "../../inline_content_analysis/client/inline_content.js",
     import.meta.url,
-  ).href
+  ).href;
 
   const asJsonModule = {
     name: `jsenv:as_json_module`,
@@ -116,24 +116,24 @@ const jsenvPluginAsModules = () => {
         context,
         searchParam: "as_json_module",
         expectedType: "json",
-      })
+      });
       if (!jsonReference) {
-        return null
+        return null;
       }
       await context.fetchUrlContent(jsonUrlInfo, {
         reference: jsonReference,
-      })
+      });
       if (context.dev) {
         context.referenceUtils.found({
           type: "js_import",
           subtype: jsonReference.subtype,
           specifier: jsonReference.url,
           expectedType: "js_module",
-        })
+        });
       } else if (context.build && jsonUrlInfo.dependents.size === 0) {
-        context.urlGraph.deleteUrlInfo(jsonUrlInfo.url)
+        context.urlGraph.deleteUrlInfo(jsonUrlInfo.url);
       }
-      const jsonText = JSON.stringify(jsonUrlInfo.content.trim())
+      const jsonText = JSON.stringify(jsonUrlInfo.content.trim());
       return {
         // here we could `export default ${jsonText}`:
         // but js engine are optimized to recognize JSON.parse
@@ -144,9 +144,9 @@ const jsenvPluginAsModules = () => {
         originalUrl: jsonUrlInfo.originalUrl,
         originalContent: jsonUrlInfo.originalContent,
         data: jsonUrlInfo.data,
-      }
+      };
     },
-  }
+  };
 
   const asCssModule = {
     name: `jsenv:as_css_module`,
@@ -157,29 +157,29 @@ const jsenvPluginAsModules = () => {
         context,
         searchParam: "as_css_module",
         expectedType: "css",
-      })
+      });
       if (!cssReference) {
-        return null
+        return null;
       }
       await context.fetchUrlContent(cssUrlInfo, {
         reference: cssReference,
-      })
+      });
       if (context.dev) {
         context.referenceUtils.found({
           type: "js_import",
           subtype: cssReference.subtype,
           specifier: cssReference.url,
           expectedType: "js_module",
-        })
+        });
       } else if (context.build && cssUrlInfo.dependents.size === 0) {
-        context.urlGraph.deleteUrlInfo(cssUrlInfo.url)
+        context.urlGraph.deleteUrlInfo(cssUrlInfo.url);
       }
       const cssText = JS_QUOTES.escapeSpecialChars(cssUrlInfo.content, {
         // If template string is choosen and runtime do not support template literals
         // it's ok because "jsenv:new_inline_content" plugin executes after this one
         // and convert template strings into raw strings
         canUseTemplateString: true,
-      })
+      });
       return {
         content: `import { InlineContent } from ${JSON.stringify(
           inlineContentClientFileUrl,
@@ -194,9 +194,9 @@ const jsenvPluginAsModules = () => {
         originalUrl: cssUrlInfo.originalUrl,
         originalContent: cssUrlInfo.originalContent,
         data: cssUrlInfo.data,
-      }
+      };
     },
-  }
+  };
 
   const asTextModule = {
     name: `jsenv:as_text_module`,
@@ -207,29 +207,29 @@ const jsenvPluginAsModules = () => {
         context,
         searchParam: "as_text_module",
         expectedType: "text",
-      })
+      });
       if (!textReference) {
-        return null
+        return null;
       }
       await context.fetchUrlContent(textUrlInfo, {
         reference: textReference,
-      })
+      });
       if (context.dev) {
         context.referenceUtils.found({
           type: "js_import",
           subtype: textReference.subtype,
           specifier: textReference.url,
           expectedType: "js_module",
-        })
+        });
       } else if (context.build && textUrlInfo.dependents.size === 0) {
-        context.urlGraph.deleteUrlInfo(textUrlInfo.url)
+        context.urlGraph.deleteUrlInfo(textUrlInfo.url);
       }
       const textPlain = JS_QUOTES.escapeSpecialChars(urlInfo.content, {
         // If template string is choosen and runtime do not support template literals
         // it's ok because "jsenv:new_inline_content" plugin executes after this one
         // and convert template strings into raw strings
         canUseTemplateString: true,
-      })
+      });
       return {
         content: `import { InlineContent } from ${JSON.stringify(
           inlineContentClientFileUrl,
@@ -242,9 +242,9 @@ export default inlineContent.text`,
         originalUrl: textUrlInfo.originalUrl,
         originalContent: textUrlInfo.originalContent,
         data: textUrlInfo.data,
-      }
+      };
     },
-  }
+  };
 
-  return [asJsonModule, asCssModule, asTextModule]
-}
+  return [asJsonModule, asCssModule, asTextModule];
+};