port js bundle regression fix (#5521)

* port js bundle regression fix

* clippy, fmt

Author: jkelleyrtp

packages/cli/src/build/assets.rs

@@ -276,6 +276,8 @@ fn legacy_asset_to_modern_asset(
             .with_minify(js.minified())
             .with_preload(js.preloaded())
             .with_static_head(js.static_head())
+            // Legacy 0.7 manganis has no module concept; default to classic script.
+            .with_module(false)
             .into_asset_options(),
         _ => AssetOptions::builder()
             .with_hash_suffix(add_hash)

packages/cli/src/build/builder.rs

@@ -1991,7 +1991,7 @@ impl AppBuilder {
         use std::fmt::Write as _;
 
         let total_ms = time_taken as usize;
-        let timeline_width = 96usize;
+        let timeline_width = 48usize;
         let max_label_width = self
             .profile_spans
             .iter()

packages/cli/src/build/web.rs

@@ -34,7 +34,10 @@
 //! ```
 
 use crate::{BuildContext, BundleFormat, Result, TraceSrc, WasmBindgen, WasmOptConfig};
-use crate::{BuildMode, BuildRequest, opt::AppManifest};
+use crate::{
+    BuildMode, BuildRequest,
+    opt::{AppManifest, js_is_module},
+};
 use anyhow::Context;
 use dioxus_cli_config::format_base_path_meta_element;
 use manganis::AssetOptions;
@@ -486,9 +489,15 @@ __wbg_init({{module_or_path: "/{}/{wasm_path}"}}).then((wasm) => {{
                         );
                     }
                     if js_options.static_head() {
+                        let source = std::path::Path::new(asset.absolute_source_path());
+                        let module_attr = if js_is_module(js_options, source) {
+                            r#" type="module""#
+                        } else {
+                            ""
+                        };
                         _ = write!(
                             head_resources,
-                            r#"<script src="/{{base_path}}/assets/{asset_path}"></script>"#
+                            r#"<script{module_attr} src="/{{base_path}}/assets/{asset_path}"></script>"#
                         );
                     }
                 }

packages/cli/src/cli/bundle.rs

@@ -59,7 +59,7 @@ impl Bundle {
 
         // Fill platform-specific defaults for package types when omitted.
         if self.package_types.is_none() {
-            self.package_types = Self::default_package_types(client.bundle);
+            self.package_types = Some(Self::default_package_types(client.bundle));
         }
 
         Self::validate_package_types_for_bundle(client.bundle, self.package_types.as_deref())?;
@@ -125,11 +125,9 @@ impl Bundle {
             }
         }
 
+        println!("Bundled {} bundles:", bundles.len());
         for bundle_path in bundles.iter() {
-            tracing::info!(
-                "Bundled app at: {}",
-                bundle_path.absolutize().unwrap().display()
-            );
+            println!("{}", bundle_path.absolutize().unwrap().display());
         }
 
         let client = client_artifacts.into_structured_output();
@@ -195,11 +193,14 @@ impl Bundle {
         Ok(bundles)
     }
 
-    fn default_package_types(bundle: BundleFormat) -> Option<Vec<PackageType>> {
+    fn default_package_types(bundle: BundleFormat) -> Vec<PackageType> {
         match bundle {
-            BundleFormat::Ios => Some(vec![crate::PackageType::Ipa]),
-            BundleFormat::Android => Some(vec![crate::PackageType::Aab]),
-            _ => None,
+            BundleFormat::Web | BundleFormat::Server => Vec::new(),
+            BundleFormat::MacOS => vec![PackageType::MacOsBundle, PackageType::Dmg],
+            BundleFormat::Windows => vec![PackageType::Nsis],
+            BundleFormat::Linux => vec![PackageType::AppImage],
+            BundleFormat::Ios => vec![PackageType::Ipa],
+            BundleFormat::Android => vec![PackageType::Aab],
         }
     }
 
@@ -271,11 +272,55 @@ mod tests {
     };
 
     #[test]
-    fn ios_bundle_defaults_to_ipa() {
+    fn bundle_formats_have_default_package_types() {
         assert_eq!(
             Bundle::default_package_types(BundleFormat::Ios),
-            Some(vec![PackageType::Ipa])
+            vec![PackageType::Ipa]
+        );
+        assert_eq!(
+            Bundle::default_package_types(BundleFormat::Android),
+            vec![PackageType::Aab]
+        );
+        assert_eq!(
+            Bundle::default_package_types(BundleFormat::MacOS),
+            vec![PackageType::MacOsBundle, PackageType::Dmg]
         );
+        assert_eq!(
+            Bundle::default_package_types(BundleFormat::Windows),
+            vec![PackageType::Nsis]
+        );
+        assert_eq!(
+            Bundle::default_package_types(BundleFormat::Linux),
+            vec![PackageType::AppImage]
+        );
+        assert_eq!(Bundle::default_package_types(BundleFormat::Web), vec![]);
+        assert_eq!(Bundle::default_package_types(BundleFormat::Server), vec![]);
+    }
+
+    #[test]
+    fn default_package_types_are_valid_for_their_bundle_format() {
+        for bundle_format in [
+            BundleFormat::Web,
+            BundleFormat::MacOS,
+            BundleFormat::Windows,
+            BundleFormat::Linux,
+            BundleFormat::Server,
+            BundleFormat::Ios,
+            BundleFormat::Android,
+        ] {
+            let package_types = Bundle::default_package_types(bundle_format);
+            Bundle::validate_package_types_for_bundle(bundle_format, Some(&package_types)).unwrap();
+        }
+    }
+
+    #[test]
+    fn omitted_package_types_are_filled_with_defaults() {
+        let mut package_types = None;
+        if package_types.is_none() {
+            package_types = Some(Bundle::default_package_types(BundleFormat::Linux));
+        }
+
+        assert_eq!(package_types, Some(vec![PackageType::AppImage]));
     }
 
     #[test]

packages/cli/src/opt/file.rs

@@ -16,17 +16,6 @@ pub(crate) fn process_file_to(
     source: &Path,
     output_path: &Path,
     esbuild_path: Option<&Path>,
-) -> anyhow::Result<()> {
-    process_file_to_with_options(options, source, output_path, false, esbuild_path)
-}
-
-/// Process a specific file asset with additional options
-pub(crate) fn process_file_to_with_options(
-    options: &AssetOptions,
-    source: &Path,
-    output_path: &Path,
-    in_folder: bool,
-    esbuild_path: Option<&Path>,
 ) -> anyhow::Result<()> {
     // If the file already exists and this is a hashed asset, then we must have a file
     // with the same hash already. The hash has the file contents and options, so if we
@@ -63,7 +52,7 @@ pub(crate) fn process_file_to_with_options(
             process_scss(options, source, &temp_path)?;
         }
         ResolvedAssetType::Js(options) => {
-            process_js(options, source, &temp_path, !in_folder, esbuild_path)?;
+            process_js(options, source, &temp_path, esbuild_path)?;
         }
         ResolvedAssetType::Image(options) => {
             process_image(options, source, &temp_path)?;

packages/cli/src/opt/folder.rs

@@ -2,7 +2,7 @@ use std::path::Path;
 
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 
-use crate::opt::file::process_file_to_with_options;
+use crate::opt::file::process_file_to;
 
 /// Process a folder, optimizing and copying all assets into the output folder
 pub fn process_folder(
@@ -40,11 +40,10 @@ fn process_file_minimal(
     output_path: &Path,
     esbuild_path: Option<&Path>,
 ) -> anyhow::Result<()> {
-    process_file_to_with_options(
+    process_file_to(
         &manganis_core::AssetOptions::builder().into_asset_options(),
         input_path,
         output_path,
-        true,
         esbuild_path,
     )?;
     Ok(())

packages/cli/src/opt/hash.rs

@@ -50,7 +50,7 @@ fn hash_file(options: &AssetOptions, source: &Path) -> anyhow::Result<AssetHash>
 
     // Hash the version of the CLI
     hash.write(crate::dx_build_info::PKG_VERSION.as_bytes());
-    hash_file_with_options(options, source, &mut hash, false)?;
+    hash_file_with_options(options, source, &mut hash)?;
 
     let hash = hash.finish();
     Ok(AssetHash::new(hash))
@@ -61,7 +61,6 @@ pub(crate) fn hash_file_with_options(
     options: &AssetOptions,
     source: &Path,
     hasher: &mut impl Hasher,
-    in_folder: bool,
 ) -> anyhow::Result<()> {
     let resolved_options = resolve_asset_options(source, options.variant());
 
@@ -73,7 +72,7 @@ pub(crate) fn hash_file_with_options(
         }
 
         ResolvedAssetType::Js(options) => {
-            hash_js(options, source, hasher, !in_folder)?;
+            hash_js(options, source, hasher)?;
         }
 
         // Otherwise, we can just hash the file contents
@@ -100,7 +99,6 @@ pub(crate) fn hash_file_with_options(
                         .into_asset_options(),
                     &path,
                     hasher,
-                    true,
                 )?;
             }
         }