feat: windows app icon + default icon from toml

packages/cli/src/build/request.rs

@@ -2274,6 +2274,11 @@ impl BuildRequest {
             _ => {}
         }
 
+        if self.triple.operating_system == OperatingSystem::Windows {
+            let icon = self.winres_icon_path();
+            cargo_args.extend(["-L".to_string(), icon.path, "-l".to_string(), icon.lib]);
+        }
+
         // Our fancy hot-patching engine needs a lot of customization to work properly.
         //
         // These args are mostly intended to be passed when *fat* linking but are generally fine to
@@ -4575,4 +4580,110 @@ __wbg_init({{module_or_path: "/{}/{wasm_path}"}}).then((wasm) => {{
 
         Ok(())
     }
+
+    fn winres_icon_path(&self) -> crate::winres::WindowsResourceLinker {
+        todo!()
+    }
+
+    fn write_winres_icon(&self) -> Result<crate::winres::WindowsResourceLinker> {
+        use crate::winres::*;
+        let bundle = &self.config.bundle;
+        let package = self.package();
+
+        let (version_str, version) = match bundle.version.as_ref() {
+            Some(v) => (v, VersionInfo::version_from_str(v)),
+            None => (
+                &format!(
+                    "{}.{}.{}",
+                    package.version.major, package.version.minor, package.version.patch
+                ),
+                VersionInfo::version_from_krate(&package.version),
+            ),
+        };
+
+        let (file_version_str, file_version) = match bundle.file_version.as_ref() {
+            Some(v) => (v, VersionInfo::version_from_str(v)),
+            None => (version_str, version),
+        };
+
+        let productname = match self.config.application.name.as_ref() {
+            Some(n) => n,
+            None => &self.bundled_app_name(),
+        };
+
+        let binding = package.description.clone().unwrap_or_default();
+        let description = match bundle.short_description.as_ref() {
+            Some(val) => val,
+            None => bundle.long_description.as_ref().unwrap_or(&binding),
+        };
+
+        let output_dir = self.bundle_dir(self.platform).join("winres");
+        std::fs::create_dir_all(&output_dir)?;
+
+        let mut winres = WindowsResource::new();
+        winres
+            .set_link(false)
+            .set_output_directory(output_dir.to_str().unwrap())
+            .set_assets_path(Some(self.asset_dir().to_string_lossy().to_string()))
+            .set_version_info(VersionInfo::PRODUCTVERSION, version)
+            .set_version_info(VersionInfo::FILEVERSION, file_version)
+            .set("ProductVersion", version_str)
+            .set("FileVersion", file_version_str)
+            .set("ProductName", productname)
+            .set("FileDescription", description);
+
+        if let Some(value) = &bundle.original_file_name {
+            winres.set("OriginalFilename", value);
+        }
+
+        if let Some(value) = &bundle.copyright {
+            winres.set("LegalCopyright", value);
+        }
+        if let Some(value) = &bundle.trademark {
+            winres.set("LegalTrademark", value);
+        }
+
+        if let Some(value) = &bundle.publisher {
+            winres.set("CompanyName", value);
+        }
+
+        if let Some(value) = &bundle.category {
+            winres.set("Category", value);
+        }
+
+        let mut default = false;
+        if let Some(windows) = bundle.windows.as_ref() {
+            if let Some(path) = windows.icon_path.as_ref() {
+                winres.set_icon(path.to_str().unwrap());
+                default = true;
+            }
+        };
+
+        if let Some(icons) = bundle.icon.as_ref() {
+            for (id, icon) in icons.iter().enumerate() {
+                if icon.ends_with(".ico") {
+                    if !default {
+                        winres.set_icon(icon);
+                        default = true;
+                    } else {
+                        winres.set_icon_with_id(icon, &id.to_string());
+                    };
+                }
+            }
+        }
+
+        if !default {
+            const DEFAULT_ICON: &[u8] = include_bytes!("../../assets/icon.ico");
+
+            let icon = output_dir.join("icon.ico");
+            winres.linker.default_icon = Some(icon.to_string_lossy().to_string());
+            let mut file = std::fs::File::create(&icon)?;
+            file.write_all(DEFAULT_ICON)?;
+            winres.set_icon(icon.to_str().unwrap());
+        }
+
+        winres.compile()?;
+
+        Ok(winres.linker)
+    }
 }

packages/cli/src/cli/bundle.rs

@@ -174,16 +174,33 @@ impl Bundle {
         }
 
         if cfg!(windows) {
-            let windows_icon_override = krate.config.bundle.windows.as_ref().map(|w| &w.icon_path);
-            if windows_icon_override.is_none() {
-                let icon_path = bundle_settings
-                    .icon
-                    .as_ref()
-                    .and_then(|icons| icons.first());
-
-                if let Some(icon_path) = icon_path {
-                    bundle_settings.icon = Some(vec![icon_path.into()]);
-                };
+            let mut windows_icon = match bundle_settings.icon.as_ref() {
+                Some(icons) => icons.iter().find(|i| i.ends_with(".ico")).cloned(),
+                None => None,
+            };
+
+            if windows_icon.is_none() {
+                let default = krate
+                    .bundle_dir(build.platform)
+                    .join("winres")
+                    .join("icon.ico");
+                tracing::info!("Windows icon not set. Using default icon.");
+
+                let path = default.to_string_lossy().to_string();
+                windows_icon = Some(path.clone());
+
+                bundle_settings.icon.get_or_insert_with(Vec::new).push(path);
+            }
+
+            let has_windows_icon_override = match krate.config.bundle.windows.as_ref() {
+                Some(windows) => windows.icon_path.is_some(),
+                None => false,
+            };
+
+            if !has_windows_icon_override {
+                let icon = windows_icon.unwrap();
+                // for now it still needs to be set even though it's deprecated
+                bundle_settings.windows.icon_path = PathBuf::from(icon);
             }
         }
 

packages/cli/src/cli/mod.rs

@@ -15,6 +15,7 @@ pub(crate) mod target;
 pub(crate) mod translate;
 pub(crate) mod update;
 pub(crate) mod verbosity;
+pub(crate) mod winres;
 
 pub(crate) use build::*;
 pub(crate) use serve::*;