Fix bundling/path errors, sidecar support, iOS/Android simulator support, asset hotreload fixes, serverfn hotrelad, native tailwind support (#2779)

* wip: fix manganis import path
* upgrade tauri bundler, convert todo!() to unimplemented!()
* feat: mobile hotreloading + ios asset configuration
* remove oid demo and its associated env vars
* nuke all the things that cause cache thrashing
* swap to Asset type
* add some more logs
* display impl for attrvalue
* dont panic on collect failure
* cut down web deps to 150
* clean up deps in a lot of places, simplify build scripts
* clean up asset resolution and cli-dev profile
* wire up absolute paths for manganis asset in a particular mode
* move document related things around to shorten compile times
* move most things to `document::Item` and then decompose the cli-config
* switch link to stylesheet for clarity in examples
* move manganis workspace example to examples folder
* decompose manganis-cli-support
* dont need mobile demo anymore
* remove gloo dialogs
* html doesnt need document
* rename hotreload to devtools
* really clean up the html crate
* fix weird rsx spacing
* clean up desktop to use callback
* clean up document a bit
* re-wire up devsocket
* fix utf css
* yeeeet that js out of here
* synthetic web system works
* web crate almost done being cleaned up
* desktop mostly cleaned up too
* clean up cli a bit
* more cli cleanup
* cli builds again
* clean up cli, inline structs, cut down number of unique types where possible
* hotreload works again for desktop and this time, mobile too
* cfg out tungstenite
* devserver err
* more refactor to cli builder
* switch to unbounded_send
* new structure is much cleaner
* add http serve subcommand
* bundled hotreload
* kick stylsheets
* clean up a bit more, split up eventloop
* amazingly serve seems done
* change from pub to pub(crate) in cli
* remove tools
* bit more polish to cli
* fix issue with join
* gracefully handle fullstack without a server
* fullstack mobile demo
* fix launch function, move projects into example-projects folder
* hoist examples
* add "run" command
* clean up launch
* remove old manual websocket receiver
* doctor command
* allow desktop to scroll
* cut apart router crate
* dont put launch in prelude
* use dioxus::launch where possible
* rename rsx, cut out hotreload tests
* remove liveview project
* bump native
* fix compile for renderers
* move sync event response out of interpreter
* move render in serve
* rollback settings change
* cli compiles, huzzah!
* change uris for asset
* fix asset
* new tui screen
* new cargo-like tui works
* very very verty close
* it works! very small bug with incorrect grapheme calc
* Clean up devserver a bit
* status sytem
* tidy up debug filters
* clean up logging situation
* Fix a number of bugs with log printing
* new printing system is more reliable
* wire up more stuff
* things working but fullstack is having issues
* fullstack works again!
* hotreloading bundled assets works again
* bundled hotreload and beginnings of macos bundling
* Hotreload desktop
* combined server builds
* add build handle
* fix fullstack assets
* make open async, add some hooks for ios
* migrate filemap to runner
* wip global crate system
* fixup bundles + organize asset
* fix asset location bug
* all the bundled reloading!
* open ios simulator!
* full hotreload support for mobile + serverfn
* basic cleanups
* clean up dx
* Move filemap
* fix cutting of newlines
* assets workibg, some android
* hoist wry/tao
* use sync locks and headers to fix issues with android
* desktop -> mac/win/linux with alias
* better logging
* feat: workspace (entire computer!) hotreload
* should rebuild toggle, ios simulator bootup
* proper mobile support in launch
* more robust handling of assets
* fix cargo
* bring back some of tauri bundle
* make warnings go away, clippy happy on cli
* some final clippy cleanups
* fmt
* move manganis to its own folder
* upgrade bundle to stable
* drastically slim down manganis, prepping for merge
* typos, failing test, docsrs config
* remove static gen test
* nix static gen test
* we use --platform web instead of --platform fullstack now
* only bind dev urls in desktop/mobile
* install gtk
* nix static gen
* split build dir by app name

packages/manganis/manganis-macro/src/asset.rs

@@ -0,0 +1,96 @@
+use manganis_core::ResourceAsset;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::{quote, ToTokens};
+use syn::{
+    parse::{Parse, ParseStream},
+    LitStr,
+};
+
+pub struct AssetParser {
+    /// The asset itself
+    asset: ResourceAsset,
+
+    /// The source of the trailing options
+    options: TokenStream2,
+}
+
+impl Parse for AssetParser {
+    // we can take
+    //
+    // This gives you the Asset type - it's generic and basically unrefined
+    // ```
+    // asset!("myfile.png")
+    // ```
+    //
+    // To narrow the type, use a method call to get the refined type
+    // ```
+    // asset!(
+    //     "myfile.png",
+    //      asset::image()
+    //        .format(ImageType::Jpg)
+    //        .size(512, 512)
+    // )
+    // ```
+    //
+    // But we need to decide the hint first before parsing the options
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        // And then parse the options
+        let src = input.parse::<LitStr>()?;
+        let asset = ResourceAsset::parse_any(&src.value()).unwrap();
+        let options = input.parse()?;
+
+        Ok(Self { asset, options })
+    }
+}
+
+impl ToTokens for AssetParser {
+    // Need to generate:
+    //
+    // - 1. absolute file path on the user's system: `/users/dioxus/dev/project/assets/blah.css`
+    // - 2. original input in case that's useful: `../blah.css`
+    // - 3. path relative to the CARGO_MANIFEST_DIR - and then we'll add a `/`: `/assets/blah.css
+    // - 4. file from which this macro was called: `/users/dioxus/dev/project/src/lib.rs`
+    // - 5: The link section containing all this data
+    // - 6: the input tokens such that the builder gets validated by the const code
+    // - 7: the bundled name `/blahcss123.css`
+    //
+    // Not that we'll use everything, but at least we have this metadata for more post-processing.
+    //
+    // For now, `2` and `3` will be the same since we don't support relative paths... a bit of
+    // a limitation from rust itself. We technically could support them but not without some hoops
+    // to jump through
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        // 1. the link section itself
+        let link_section = crate::generate_link_section(&self.asset);
+
+        // 2. original
+        let input = self.asset.input.display().to_string();
+
+        // 3. resolved on the user's system
+        let local = self.asset.absolute.display().to_string();
+
+        // 4. bundled
+        let bundled = self.asset.bundled.to_string();
+
+        // 5. source tokens
+        let option_source = &self.options;
+
+        tokens.extend(quote! {
+            Asset::new(
+                {
+                    #link_section
+                    manganis::Asset {
+                        // "/assets/blah.css"
+                        input: #input,
+
+                        // "/users/dioxus/dev/app/assets/blah.css"
+                        local: #local,
+
+                        // "/blahcss123.css"
+                        bundled: #bundled,
+                    }
+                }
+            ) #option_source
+        })
+    }
+}

packages/manganis/manganis-macro/src/lib.rs

@@ -0,0 +1,19 @@
+#![doc = include_str!("../README.md")]
+#![deny(missing_docs)]
+
+use proc_macro::TokenStream;
+use quote::{quote, ToTokens};
+use syn::parse_macro_input;
+
+pub(crate) mod asset;
+pub(crate) mod linker;
+
+use linker::generate_link_section;
+
+/// The asset macro collects assets that will be included in the final binary
+#[proc_macro]
+pub fn asset(input: TokenStream) -> TokenStream {
+    let asset = parse_macro_input!(input as asset::AssetParser);
+
+    quote! { #asset }.into_token_stream().into()
+}

packages/manganis/manganis-macro/src/linker.rs

@@ -0,0 +1,21 @@
+use proc_macro2::TokenStream as TokenStream2;
+use serde::Serialize;
+
+/// this new approach will store the assets descriptions *inside the executable*.
+/// The trick is to use the `link_section` attribute.
+/// We force rust to store a json representation of the asset description
+/// inside a particular region of the binary, with the label "manganis".
+/// After linking, the "manganis" sections of the different executables will be merged.
+pub fn generate_link_section(asset: &impl Serialize) -> TokenStream2 {
+    let position = proc_macro2::Span::call_site();
+    let asset_description = serde_json::to_string(asset).unwrap();
+    let len = asset_description.as_bytes().len();
+    let asset_bytes = syn::LitByteStr::new(asset_description.as_bytes(), position);
+    let section_name = syn::LitStr::new(manganis_core::LinkSection::CURRENT.link_section, position);
+
+    quote::quote! {
+        #[link_section = #section_name]
+        #[used]
+        static ASSET: [u8; #len] = * #asset_bytes;
+    }
+}