diff --git a/Cargo.toml b/Cargo.toml index 9b31c251f..a35636649 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,6 +9,7 @@ members = [ "packages/core-macro", "packages/router", "packages/ssr", + "packages/webview", # "packages/macro", # TODO @Jon, share the validation code # "packages/web", diff --git a/examples/fc_macro.rs b/examples/fc_macro.rs index 9e6a6990a..cff3de0e9 100644 --- a/examples/fc_macro.rs +++ b/examples/fc_macro.rs @@ -12,7 +12,10 @@ fn main() { /// This macro makes writing functional components elegant, similar to how Rocket parses URIs. /// /// You don't actually *need* this macro to be productive, but it makes life easier, and components cleaner. -/// This approach also integrates well with tools like Rust-Analyzer +/// This approach also integrates well with tools like Rust-Analyzer. +/// +/// Notice that Context is normally generic over props, but RA doesn't care when in proc-macro mode. +/// Also notice that ctx.props still works like you would expect, so migrating to the macro is easy. #[fc] fn example(ctx: &Context, name: String) -> VNode { html! {
"Hello, {name}!"
} diff --git a/examples/tide_ssr.rs b/examples/tide_ssr.rs index 66ac42498..974786ee0 100644 --- a/examples/tide_ssr.rs +++ b/examples/tide_ssr.rs @@ -76,8 +76,9 @@ async fn fibsum(req: Request<()>) -> tide::Result {
{format!("{}",fib_n)}
- + + // Try another
{"Click to try another number"} diff --git a/packages/core-macro/src/lib.rs b/packages/core-macro/src/lib.rs index 2b268c477..1327329b0 100644 --- a/packages/core-macro/src/lib.rs +++ b/packages/core-macro/src/lib.rs @@ -46,8 +46,6 @@ fn function_component_impl( // } let ret_type = quote_spanned!(return_type.span()=> VNode); - // let ret_type = quote_spanned!(return_type.span()=> ::VNode); - // let ret_type = quote_spanned!(return_type.span()=> ::yew::html::Html); let quoted = quote! { #[doc(hidden)] @@ -69,22 +67,6 @@ fn function_component_impl( } #[allow(non_snake_case)] pub use __component_blah::component as #function_name; - - - - - // #vis struct #function_name; - - // impl ::yew_functional::FunctionProvider for #function_name { - // type TProps = #props_type; - - // fn run(#arg) -> #ret_type { - // #block - // } - // } - - // #(#attrs)* - // #vis type #component_name = ::yew_functional::FunctionComponent<#function_name>; }; // let quoted = quote! { // #[doc(hidden)] @@ -149,6 +131,31 @@ impl Parse for FunctionComponent { // Extract the "context" object let props_type = validate_context_arg(&first_arg)?; + /* + Extract the rest of the function arguments into a struct body + We require all inputs are strongly typed with names so we can destructure into the function body when expanded + + + */ + // let rest = inputs + // .map(|f| { + // // + // match f { + // FnArg::Typed(pat) => { + // match *pat.pat { + // syn::Pat::Type(asd) => {} + // _ => {} + // }; + // // + // } + // FnArg::Receiver(_) => {} + // } + // // let name = f + // let stream = f.into_token_stream(); + // (stream) + // }) + // .collect::>(); + // Collect the rest of the args into a list of definitions to be used by the inline struct // Checking after param parsing may make it a little inefficient diff --git a/packages/core/src/lib.rs b/packages/core/src/lib.rs index 3d7bca957..87f52b92c 100644 --- a/packages/core/src/lib.rs +++ b/packages/core/src/lib.rs @@ -149,9 +149,29 @@ pub mod virtual_dom { /// } /// ``` pub struct Context<'source, T> { + /// Direct access to the properties used to create this component. pub props: &'source T, } + impl<'a, T> Context<'a, T> { + /// Access a parent context + pub fn parent_context(&self) -> C { + todo!("Context API is not ready yet") + } + + /// Create a subscription that schedules a future render for the reference component + pub fn subscribe(&self) -> impl FnOnce() -> () { + todo!("Subscription API is not ready yet"); + || {} + } + + /// The `Enter` API is an internal way of tracking the location in the Dioxus Virtual DOM + /// The Context object consumes itself, producing a new lifetime without reallocating + fn enter(self) -> Self { + todo!("Entrance API for reusing Context object not ready yet") + } + } + pub trait Properties {} // Auto derive for pure components diff --git a/packages/web/README.md b/packages/web/README.md new file mode 100644 index 000000000..0af6145f1 --- /dev/null +++ b/packages/web/README.md @@ -0,0 +1,5 @@ +# Dioxus-Web + +Build interactive user experiences directly in the web browser! + +Dioxus-web provides a `WebsysRenderer` for the Dioxus Virtual Dom that handles events, progresses components, and updates the actual DOM using web-sys methods. diff --git a/packages/webview/Cargo.toml b/packages/webview/Cargo.toml new file mode 100644 index 000000000..b5dae6d27 --- /dev/null +++ b/packages/webview/Cargo.toml @@ -0,0 +1,10 @@ +[package] +name = "dioxus-webview" +version = "0.0.0" +authors = ["Jonathan Kelley "] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +webview = "0.1.1" diff --git a/packages/webview/README.md b/packages/webview/README.md new file mode 100644 index 000000000..d406f5246 --- /dev/null +++ b/packages/webview/README.md @@ -0,0 +1,39 @@ +# Dioxus-webview + +Dioxus-webview bridges virtual and Webview DOMs together to make simple, portable, desktop applications. + +Dioxus-webview is an attempt at making a simpler "Tauri" where creating desktop applications is as simple as: + +```rust +// main.rs +fn main() { + dioxus_webview::new(|ctx| { + let (count, set_count) = use_state(ctx, || 0); + html! { +
+

"Dioxus Desktop Demo"

+

"Count is {count}"

+ +
+ } + }) + .configure_webview(|view| { + // custom webview config options + }) + .launch(); +} +``` + +and then to create a native .app: + +``` +dioxus bundle --platform macOS +``` + +## Goals + +Because the host VirtualDOM is running in its own native process, native applications can unlock their full potential. Dioxus-webview is designed to be a 100% rust alternative to ElectronJS without the memory overhead or bloat of ElectronJS apps. + +By bridging the native process, desktop apps can access full multithreading power, peripheral support, hardware access, and native filesystem controls without the hassle of web technologies. Our goal with Dioxus-webview is to make it easy to ship both a web and native application, and quickly see large performance boosts without having to re-write the whole stack. As the dioxus ecosystem grows, we hope to see 3rd parties providing wrappers for storage, offline mode, etc that supports both web and native technologies. diff --git a/packages/webview/src/lib.rs b/packages/webview/src/lib.rs new file mode 100644 index 000000000..31e1bb209 --- /dev/null +++ b/packages/webview/src/lib.rs @@ -0,0 +1,7 @@ +#[cfg(test)] +mod tests { + #[test] + fn it_works() { + assert_eq!(2 + 2, 4); + } +}