remove example code

-[package]
-name = "mogwai-list"
-version = "0.0.0"
-authors = ["Georg Hopp <georg@steffers.org>"]
-workspace = ".."
-edition = "2018"
-
-[lib]
-crate-type = ["cdylib", "rlib"]
-
-[features]
-default = ["console_error_panic_hook"]
-
-[dependencies]
-artshop-common = { path = "../common" }
-katex = { version = "0.4", default-features = false, features = ["wasm-js"] }
-pulldown-cmark = "0.9"
-console_log = "^0.1"
-log = "^0.4"
-serde = { version = "^1.0", features = ["derive"] }
-serde_json = "^1.0"
-wasm-bindgen = "^0.2"
-wasm-bindgen-futures = "^0.4"
-
-# The `console_error_panic_hook` crate provides better debugging of panics by
-# logging them with `console.error`. This is great for development, but requires
-# all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
-# code size when deploying.
-console_error_panic_hook = { version = "0.1.6", optional = true }
-wee_alloc = { version = "0.4.2", optional = true }
-js-sys = "^0.3"
-
-[dependencies.mogwai]
-version = "^0.5"
-
-[dependencies.web-sys]
-version = "^0.3"
-features = [
-  "Document",
-  "DomParser",
-  "Headers",
-  "HtmlElement",
-  "HtmlInputElement",
-  "MouseEvent",
-  "Node",
-  "Request",
-  "RequestInit",
-  "RequestMode",
-  "Response",
-  "SupportedType",
-  "Window",
-]
-
-[dev-dependencies]
-wasm-bindgen-test = "0.2"

-#![allow(unused_braces)]
-use log::Level;
-use mogwai::{futures, prelude::*};
-use std::panic;
-use wasm_bindgen::prelude::*;
-
-/// An item widget.
-/// Keeps track of clicks.
-#[derive(Clone, Debug)]
-struct Item {
-    id: usize,
-    clicks: Model<u32>,
-}
-
-/// An item's update messages.
-#[derive(Clone)]
-enum ItemMsg {
-    /// The user clicked
-    Click,
-    /// The user requested this item be removed
-    Remove,
-}
-
-/// One item's logic loop.
-async fn item_logic(
-    id: usize,
-    clicks: Model<u32>,
-    mut from_view: broadcast::Receiver<ItemMsg>,
-    to_list: broadcast::Sender<ListMsg>,
-) {
-    loop {
-        match from_view.recv().await {
-            Ok(ItemMsg::Click) => {
-                clicks.visit_mut(|c| *c += 1).await;
-            }
-            Ok(ItemMsg::Remove) => {
-                to_list.broadcast(ListMsg::RemoveItem(id)).await.unwrap();
-                break;
-            }
-            Err(_) => break,
-        }
-    }
-    log::info!("item {} logic loop is done", id);
-}
-
-// ANCHOR: item_view
-fn item_view(
-    clicks: impl Stream<Item = u32> + Sendable,
-    to_logic: broadcast::Sender<ItemMsg>,
-) -> ViewBuilder<Dom> {
-    builder! {
-        <li>
-            <button
-                style:cursor="pointer"
-                on:click=to_logic.sink().contra_map(|_| ItemMsg::Click)>
-                "Increment"
-            </button>
-            <button
-                style:cursor="pointer"
-                on:click=to_logic.sink().contra_map(|_| ItemMsg::Remove)>
-                "Remove"
-            </button>
-            " "
-            <span>
-            {
-                ("", clicks.map(|clicks| match clicks {
-                    1 => "1 click".to_string(),
-                    n => format!("{} clicks", n),
-                }))
-            }
-            </span>
-        </li>
-    }
-}
-// ANCHOR_END: item_view
-
-/// Create a new item component.
-fn item(id: usize, clicks: Model<u32>, to_list: broadcast::Sender<ListMsg>) -> Component<Dom> {
-    let (tx, rx) = broadcast::bounded(1);
-    Component::from(item_view(clicks.stream(), tx)).with_logic(item_logic(id, clicks, rx, to_list))
-}
-
-#[derive(Clone)]
-enum ListMsg {
-    /// Create a new item
-    NewItem,
-    /// Remove the item with the given id
-    RemoveItem(usize),
-}
-
-// ANCHOR: list_logic_coms
-/// Launch the logic loop of our list of items.
-async fn list_logic(
-    input: broadcast::Receiver<ListMsg>,
-    tx_patch_children: mpmc::Sender<ListPatch<ViewBuilder<Dom>>>,
-) {
-    // Set up our communication from items to this logic loop by
-    // * creating a list patch model
-    // * creating a channel to go from item to list logic (aka here)
-    // * creating a side-effect stream (for_each) that runs for each item patch
-    // * map patches of Item to patches of builders and send that to our view
-    //   through tx_patch_children
-    let mut items: ListPatchModel<Item> = ListPatchModel::new();
-    let (to_list, from_items) = broadcast::bounded::<ListMsg>(1);
-    let to_list = to_list.clone();
-    let all_item_patches = items.stream().map(move |patch| {
-        log::info!("mapping patch for item: {:?}", patch);
-        let to_list = to_list.clone();
-        patch.map(move |Item { id, clicks }: Item| {
-            let to_list = to_list.clone();
-            let component = item(id, clicks, to_list);
-            let builder: ViewBuilder<Dom> = component.into();
-            builder
-        })
-    }).for_each(move |patch| {
-        let tx_patch_children = tx_patch_children.clone();
-        async move {
-            tx_patch_children.send(patch).await.unwrap();
-        }
-    });
-    mogwai::spawn(all_item_patches);
-    // ANCHOR_END: list_logic_coms
-    // ANCHOR: list_logic_loop
-    // Combine the input from our view with the input from our items
-    let mut input = futures::stream::select_all(vec![input, from_items]);
-    let mut next_id = 0;
-    loop {
-        match input.next().await {
-            Some(ListMsg::NewItem) => {
-                log::info!("creating a new item");
-                let item: Item = Item {
-                    id: next_id,
-                    clicks: Model::new(0),
-                };
-                next_id += 1;
-                // patch our items easily and _item_patch_stream's for_each runs automatically,
-                // keeping the list of item views in sync
-                items.list_patch_push(item);
-            }
-            Some(ListMsg::RemoveItem(id)) => {
-                log::info!("removing item: {}", id);
-                let mut may_index = None;
-                'find_item_by_id: for (item, index) in items.read().await.iter().zip(0..) {
-                    if item.id == id {
-                        may_index = Some(index);
-                        break 'find_item_by_id;
-                    }
-                }
-
-                if let Some(index) = may_index {
-                    // patch our items to remove the item at the index
-                    let _ = items.list_patch_remove(index);
-                }
-            }
-            _ => {
-                log::error!("Leaving list logic loop - this shouldn't happen");
-                break;
-            },
-        }
-    }
-    // ANCHOR_END: list_logic_loop
-}
-
-// ANCHOR: list_view
-fn list_view<T>(to_logic: broadcast::Sender<ListMsg>, children: T) -> ViewBuilder<Dom>
-where
-    T: Stream<Item = ListPatch<ViewBuilder<Dom>>> + Sendable,
-{
-    builder! {
-        <fieldset>
-            <legend>"A List of Gizmos"</legend>
-                <button style:cursor="pointer" on:click=to_logic.sink().contra_map(|_| ListMsg::NewItem)>
-                "Create a new item"
-            </button>
-            <fieldset>
-                <legend>"Items"</legend>
-                <ol patch:children=children>
-                </ol>
-            </fieldset>
-        </fieldset>
-    }
-}
-// ANCHOR_END: list_view
-
-/// Create our list component.
-fn list() -> Component<Dom> {
-    let (logic_tx, logic_rx) = broadcast::bounded(1);
-    let (item_patch_tx, item_patch_rx) = mpmc::bounded(1);
-    Component::from(list_view(logic_tx, item_patch_rx))
-        .with_logic(list_logic(logic_rx, item_patch_tx))
-}
-
-#[wasm_bindgen]
-pub fn main(parent_id: Option<String>) -> Result<(), JsValue> {
-    panic::set_hook(Box::new(console_error_panic_hook::hook));
-    console_log::init_with_level(Level::Trace).unwrap();
-    let component = list();
-    let view = component.build().unwrap();
-
-    if let Some(id) = parent_id {
-        let parent = mogwai::utils::document().get_element_by_id(&id).unwrap();
-        view.run_in_container(&parent)
-    } else {
-        view.run()
-    }
-}