Chore: hoist example projects for discoverability (#2959)

* hoist example projects, remove oidc

* move over example projects from the separate repo

* Update ecommerce site to the latest version of dioxus

* update wifi scanner to 0.5

* drop the chatbot example; might be restored in a separate PR

---------

Co-authored-by: Evan Almloff <evanalmloff@gmail.com>

example-projects/file-explorer/src/main.rs

@@ -0,0 +1,135 @@
+//! Example: File Explorer
+//!
+//! This is a fun little desktop application that lets you explore the file system.
+//!
+//! This example is interesting because it's mixing filesystem operations and GUI, which is typically hard for UI to do.
+//! We store the state entirely in a single signal, making the explorer logic fairly easy to reason about.
+
+use std::env::current_dir;
+use std::path::PathBuf;
+
+use dioxus::desktop::{Config, WindowBuilder};
+use dioxus::prelude::*;
+
+fn main() {
+    LaunchBuilder::desktop()
+        .with_cfg(Config::new().with_window(WindowBuilder::new().with_resizable(true)))
+        .launch(app)
+}
+
+fn app() -> Element {
+    let mut files = use_signal(Files::new);
+
+    rsx! {
+        head::Link {
+            rel: "stylesheet",
+            href: asset!("./assets/fileexplorer.css")
+        }
+        div {
+            head::Link { href: "https://fonts.googleapis.com/icon?family=Material+Icons", rel: "stylesheet" }
+            header {
+                i { class: "material-icons icon-menu", "menu" }
+                h1 { "Files: " {files.read().current()} }
+                span { }
+                i { class: "material-icons", onclick: move |_| files.write().go_up(), "logout" }
+            }
+            main {
+                for (dir_id, path) in files.read().path_names.iter().enumerate() {
+                    {
+                        let path_end = path.components().last().map(|p|p.as_os_str()).unwrap_or(path.as_os_str()).to_string_lossy();
+                        let path = path.display();
+                        rsx! {
+                            div { class: "folder", key: "{path}",
+                                i { class: "material-icons",
+                                    onclick: move |_| files.write().enter_dir(dir_id),
+                                    if path_end.contains('.') {
+                                        "description"
+                                    } else {
+                                        "folder"
+                                    }
+                                    p { class: "cooltip", "0 folders / 0 files" }
+                                }
+                                h1 { "{path_end}" }
+                            }
+                        }
+                    }
+                }
+                if let Some(err) = files.read().err.as_ref() {
+                    div {
+                        code { "{err}" }
+                        button { onclick: move |_| files.write().clear_err(), "x" }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// A simple little struct to hold the file explorer state
+///
+/// We don't use any fancy signals or memoization here - Dioxus is so fast that even a file explorer can be done with a
+/// single signal.
+struct Files {
+    current_path: PathBuf,
+    path_names: Vec<PathBuf>,
+    err: Option<String>,
+}
+
+impl Files {
+    fn new() -> Self {
+        let mut files = Self {
+            current_path: std::path::absolute(current_dir().unwrap()).unwrap(),
+            path_names: vec![],
+            err: None,
+        };
+
+        files.reload_path_list();
+
+        files
+    }
+
+    fn reload_path_list(&mut self) {
+        let paths = match std::fs::read_dir(&self.current_path) {
+            Ok(e) => e,
+            Err(err) => {
+                let err = format!("An error occurred: {err:?}");
+                self.err = Some(err);
+                return;
+            }
+        };
+        let collected = paths.collect::<Vec<_>>();
+
+        // clear the current state
+        self.clear_err();
+        self.path_names.clear();
+
+        for path in collected {
+            self.path_names.push(path.unwrap().path().to_path_buf());
+        }
+    }
+
+    fn go_up(&mut self) {
+        self.current_path = match self.current_path.parent() {
+            Some(path) => path.to_path_buf(),
+            None => {
+                self.err = Some("Cannot go up from the root directory".to_string());
+                return;
+            }
+        };
+        self.reload_path_list();
+    }
+
+    fn enter_dir(&mut self, dir_id: usize) {
+        let path = &self.path_names[dir_id];
+        self.current_path = path.clone();
+        self.reload_path_list();
+    }
+
+    fn current(&self) -> String {
+        self.current_path.display().to_string()
+    }
+
+    fn clear_err(&mut self) {
+        self.err = None;
+    }
+}