Hi,

Thanks for creating SilkenWeb – so far I really enjoy the nice macro-less API!

(It's smooth as silk... 😅)

While looking at the source code, I noticed the following function:

fn set_attribute(dom_element: &dom::Element, name: impl AsRef<str>, value: impl AsRef<str>) {
    clone!(dom_element);
    let name = name.as_ref().to_string();
    let value = value.as_ref().to_string();

    queue_update(move || dom_element.set_attribute(&name, &value).unwrap());
}

Basically, you:

1. request something that can be turned into &str
2. convert it (potentially a String) into a &str
3. and then you turn that &str into a String.

That doesn't seem to make sense to me – is there a reason for that?

I believe, ToString would be the right trait to request:

fn foo<T: ToString>(s: T) {
    println!("{}", s.to_string())
}

fn main() {
    foo("bar");
    foo("bar".to_string())
}

Once a text input field has been edited by hand (i.e. type something into the field), the displayed input value will no longer be updated from a read signal. The input value is update just fine before the edit, it is only after the edit that it stops.

Example reproduction:

fn main() {
    let message = Signal::new("".to_owned());
    let message_read = message.read();
    let message_write = message.write();

    let app = div()
        .child(input().value(message_read))
        .child(button().text("Overwrite Message").on_click(move |_,_| {
            message_write.replace(|_| "Overwrite worked!".to_owned())
        }));

    mount("app", app);
}

In the example above, the overwrite button only appears to work if you haven't already typed something into the input.

P.S. I'm a big fan. Of all the rust web frameworks I've tried, this is definitely my favorite. I hope you keep up the great work!

Routing is a bit basic at the moment. Currently it just provides a URL string signal. We should provide a more structured URL with methods to access different components. The url library from servo looks like a great parser for server side apps, but would bloat client side apps too much. We need a lightweight wrapper around the browser's URL parser on the client side and a wrapper around the url library on the server side.

I am new to silkenweb, excited with the non-vdom idea.

Are there any simple and quick performance benchmark compared to other rust-wasm frameworks, such as yew, seed, sycamore?

thank you

Bumps regex from 1.5.4 to 1.5.5.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

There should be an implementation of routing on the server. Url should be wrapped in our own struct with a client and server side implementation provided via a trait. The implementation should be selected at compile time with cfg attrs.

Currently we don't distinguish between signal initialization and signal changes when mapping over them. TodoMVC storage needs a way to distinguish the 2 conditions. One option is to have a map alternative that's passed an initializing flag.

Elements should have a .cache() method that globally caches the node by call site (and key?) and uses clone_node to generate the elements. Will this work for reactive elements?

Currently Element mirrors the real DOM tree. It only really needs to store a tree of reactive nodes and their reactive children. Is this even worth implementing?

Can we implement a flatten method on nested ReadSignals?

    impl<T> ReadSignal<ReadSignal<T>> {
        fn flatten(&self) -> ReadSignal<T>;
    }

Accumulators should be generalized in terms of actions and inverses. This enables And and Or accumulators which keep a running count of how many items are true.