Showing preview only (5,096K chars total). Download the full file or copy to clipboard to get everything.
Repository: leptos-rs/leptos
Branch: main
Commit: 9f30d5eb2b3d
Files: 1358
Total size: 4.6 MB
Directory structure:
gitextract_0avvtdt6/
├── .config/
│ └── nextest.toml
├── .github/
│ ├── FUNDING.yml
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.md
│ │ ├── config.yml
│ │ └── feature_request.md
│ ├── dependabot.yml
│ └── workflows/
│ ├── autofix.yml
│ ├── ci.yml
│ ├── get-example-changed.yml
│ ├── get-examples-matrix.yml
│ ├── get-leptos-changed.yml
│ ├── get-leptos-matrix.yml
│ ├── publish-book.yml
│ └── run-cargo-make-task.yml
├── .gitignore
├── ARCHITECTURE.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── Cargo.toml
├── LICENSE
├── Makefile.toml
├── README.md
├── SECURITY.md
├── TODO.md
├── any_error/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── any_spawner/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ ├── src/
│ │ └── lib.rs
│ └── tests/
│ ├── already_set_error.rs
│ ├── async_executor.rs
│ ├── custom_executor.rs
│ ├── custom_runtime.rs
│ ├── executor_tick.rs
│ ├── futures_executor.rs
│ ├── futures_runtime.rs
│ ├── glib.rs
│ ├── local_custom_executor.rs
│ ├── multiple_tasks.rs
│ ├── tokio_executor.rs
│ └── wasm_bindgen_tests.rs
├── benchmarks/
│ ├── Cargo.toml
│ └── src/
│ ├── lib.rs
│ ├── reactive.rs
│ ├── ssr.rs
│ └── todomvc/
│ ├── leptos.rs
│ ├── mod.rs
│ ├── sycamore.rs
│ ├── tachys.rs
│ ├── tera.rs
│ └── yew.rs
├── cargo-make/
│ ├── check-minimal-versions.toml
│ ├── lint.toml
│ ├── main.toml
│ ├── test.toml
│ └── wasm-test.toml
├── const_str_slice_concat/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ └── src/
│ └── lib.rs
├── docs/
│ ├── COMMON_BUGS.md
│ ├── book_ru/
│ │ ├── .gitignore
│ │ ├── README.md
│ │ ├── book.toml
│ │ ├── mdbook-admonish.css
│ │ └── src/
│ │ ├── 01_introduction.md
│ │ ├── 15_global_state.md
│ │ ├── SUMMARY.md
│ │ ├── appendix_reactive_graph.md
│ │ ├── async/
│ │ │ ├── 10_resources.md
│ │ │ ├── 11_suspense.md
│ │ │ ├── 12_transition.md
│ │ │ ├── 13_actions.md
│ │ │ └── README.md
│ │ ├── csr_wrapping_up.md
│ │ ├── deployment/
│ │ │ ├── README.md
│ │ │ └── binary_size.md
│ │ ├── getting_started/
│ │ │ ├── README.md
│ │ │ ├── community_crates.md
│ │ │ └── leptos_dx.md
│ │ ├── interlude_projecting_children.md
│ │ ├── interlude_styling.md
│ │ ├── islands.md
│ │ ├── metadata.md
│ │ ├── progressive_enhancement/
│ │ │ ├── README.md
│ │ │ └── action_form.md
│ │ ├── reactivity/
│ │ │ ├── 14_create_effect.md
│ │ │ ├── README.md
│ │ │ ├── interlude_functions.md
│ │ │ └── working_with_signals.md
│ │ ├── router/
│ │ │ ├── 16_routes.md
│ │ │ ├── 17_nested_routing.md
│ │ │ ├── 18_params_and_queries.md
│ │ │ ├── 19_a.md
│ │ │ ├── 20_form.md
│ │ │ └── README.md
│ │ ├── server/
│ │ │ ├── 25_server_functions.md
│ │ │ ├── 26_extractors.md
│ │ │ ├── 27_response.md
│ │ │ └── README.md
│ │ ├── ssr/
│ │ │ ├── 21_cargo_leptos.md
│ │ │ ├── 22_life_cycle.md
│ │ │ ├── 23_ssr_modes.md
│ │ │ ├── 24_hydration_bugs.md
│ │ │ └── README.md
│ │ ├── testing.md
│ │ └── view/
│ │ ├── 01_basic_component.md
│ │ ├── 02_dynamic_attributes.md
│ │ ├── 03_components.md
│ │ ├── 04_iteration.md
│ │ ├── 04b_iteration.md
│ │ ├── 05_forms.md
│ │ ├── 06_control_flow.md
│ │ ├── 07_errors.md
│ │ ├── 08_parent_child.md
│ │ ├── 09_component_children.md
│ │ ├── README.md
│ │ └── builder.md
│ └── logos/
│ └── .gitignore
├── either_of/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── examples/
│ ├── Makefile.toml
│ ├── README.md
│ ├── SSR_NOTES.md
│ ├── action-form-error-handling/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.scss
│ ├── axum_js_ssr/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── package.json
│ │ ├── src/
│ │ │ ├── api.rs
│ │ │ ├── app.rs
│ │ │ ├── consts.rs
│ │ │ ├── hljs.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.scss
│ ├── cargo-make/
│ │ ├── cargo-leptos-compress.toml
│ │ ├── cargo-leptos-split-webdriver-test.toml
│ │ ├── cargo-leptos-test.toml
│ │ ├── cargo-leptos-webdriver-test.toml
│ │ ├── cargo-leptos.toml
│ │ ├── clean.toml
│ │ ├── client-process.toml
│ │ ├── compile.toml
│ │ ├── deno-build.toml
│ │ ├── lint.toml
│ │ ├── main.toml
│ │ ├── node.toml
│ │ ├── playwright-test.toml
│ │ ├── playwright-trunk-test.toml
│ │ ├── playwright.toml
│ │ ├── process.toml
│ │ ├── scripts/
│ │ │ └── web-report.sh
│ │ ├── server-process.toml
│ │ ├── trunk_server.toml
│ │ ├── wasm-test.toml
│ │ └── webdriver.toml
│ ├── counter/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── tests/
│ │ └── web.rs
│ ├── counter_isomorphic/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ └── src/
│ │ ├── counters.rs
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── counter_url_query/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── counter_without_macros/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── tests/
│ │ ├── business.rs
│ │ └── web.rs
│ ├── counters/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── .gitignore
│ │ │ ├── package.json
│ │ │ ├── playwright.config.ts
│ │ │ └── tests/
│ │ │ ├── add_1k_counters.spec.ts
│ │ │ ├── add_counter.spec.ts
│ │ │ ├── clear_counters.spec.ts
│ │ │ ├── decrement_count.spec.ts
│ │ │ ├── enter_count.spec.ts
│ │ │ ├── fixtures/
│ │ │ │ └── counters_page.ts
│ │ │ ├── increment_count.spec.ts
│ │ │ ├── remove_counter.spec.ts
│ │ │ └── view_counters.spec.ts
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── tests/
│ │ └── web.rs
│ ├── directives/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── tests/
│ │ └── web.rs
│ ├── error_boundary/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── .gitignore
│ │ │ ├── package.json
│ │ │ ├── playwright.config.ts
│ │ │ └── tests/
│ │ │ ├── clear_number.spec.ts
│ │ │ ├── click_down_arrow.spec.ts
│ │ │ ├── click_up_arrow.spec.ts
│ │ │ ├── fixtures/
│ │ │ │ └── home_page.ts
│ │ │ ├── open_app.spec.ts
│ │ │ └── type_number.spec.ts
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── errors_axum/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── error_template.rs
│ │ │ ├── errors.rs
│ │ │ ├── landing.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style.css
│ ├── fetch/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── hackernews/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── api.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ ├── routes/
│ │ │ │ ├── nav.rs
│ │ │ │ ├── stories.rs
│ │ │ │ ├── story.rs
│ │ │ │ └── users.rs
│ │ │ └── routes.rs
│ │ └── style.css
│ ├── hackernews_axum/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── api.rs
│ │ │ ├── error_template.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ ├── routes/
│ │ │ │ ├── nav.rs
│ │ │ │ ├── stories.rs
│ │ │ │ ├── story.rs
│ │ │ │ └── users.rs
│ │ │ └── routes.rs
│ │ └── style.css
│ ├── hackernews_islands_axum/
│ │ ├── .cargo/
│ │ │ └── config.wasm.toml
│ │ ├── Cargo.toml
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── api.rs
│ │ │ ├── fallback.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ ├── routes/
│ │ │ │ ├── nav.rs
│ │ │ │ ├── stories.rs
│ │ │ │ ├── story.rs
│ │ │ │ └── users.rs
│ │ │ └── routes.rs
│ │ └── style.css
│ ├── hackernews_js_fetch/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── deno.jsonc
│ │ ├── public/
│ │ │ └── style.css
│ │ ├── run.ts
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── api.rs
│ │ ├── lib.rs
│ │ ├── routes/
│ │ │ ├── nav.rs
│ │ │ ├── stories.rs
│ │ │ ├── story.rs
│ │ │ └── users.rs
│ │ └── routes.rs
│ ├── islands/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style.css
│ ├── islands_router/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── mock_data.json
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style.css
│ ├── js-framework-benchmark/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── tests/
│ │ └── web.rs
│ ├── lazy_routes/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── Cargo.toml
│ │ │ ├── Makefile.toml
│ │ │ ├── README.md
│ │ │ ├── features/
│ │ │ │ ├── basic.feature
│ │ │ │ ├── duplicate_name.feature
│ │ │ │ └── shared_chunks.feature
│ │ │ └── tests/
│ │ │ ├── app_suite.rs
│ │ │ └── fixtures/
│ │ │ ├── action.rs
│ │ │ ├── check.rs
│ │ │ ├── find.rs
│ │ │ ├── mod.rs
│ │ │ └── world/
│ │ │ ├── action_steps.rs
│ │ │ ├── check_steps.rs
│ │ │ └── mod.rs
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.scss
│ ├── parent_child/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── portal/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── tests/
│ │ └── web.rs
│ ├── regression/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── Cargo.toml
│ │ │ ├── Makefile.toml
│ │ │ ├── README.md
│ │ │ ├── features/
│ │ │ │ ├── issue_4005.feature
│ │ │ │ ├── issue_4088.feature
│ │ │ │ ├── issue_4217.feature
│ │ │ │ ├── issue_4251.feature
│ │ │ │ ├── issue_4285.feature
│ │ │ │ ├── issue_4296.feature
│ │ │ │ ├── issue_4324.feature
│ │ │ │ ├── issue_4492.feature
│ │ │ │ ├── pr_4015.feature
│ │ │ │ └── pr_4091.feature
│ │ │ └── tests/
│ │ │ ├── app_suite.rs
│ │ │ └── fixtures/
│ │ │ ├── action.rs
│ │ │ ├── check.rs
│ │ │ ├── find.rs
│ │ │ ├── mod.rs
│ │ │ └── world/
│ │ │ ├── action_steps.rs
│ │ │ ├── check_steps.rs
│ │ │ └── mod.rs
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── issue_4005.rs
│ │ │ ├── issue_4088.rs
│ │ │ ├── issue_4217.rs
│ │ │ ├── issue_4285.rs
│ │ │ ├── issue_4296.rs
│ │ │ ├── issue_4324.rs
│ │ │ ├── issue_4492.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ ├── pr_4015.rs
│ │ │ └── pr_4091.rs
│ │ └── style/
│ │ └── main.scss
│ ├── router/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── package.json
│ │ │ ├── playwright.config.ts
│ │ │ └── tests/
│ │ │ └── router.spec.ts
│ │ ├── index.html
│ │ ├── package.json
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── api.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style.css
│ ├── server_fns_axum/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── error_template.rs
│ │ │ ├── errors.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ └── middleware.rs
│ │ ├── style.css
│ │ └── watched_files/
│ │ └── .gitkeep
│ ├── slots/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── spread/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── ssr_modes/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.scss
│ ├── ssr_modes_axum/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.scss
│ ├── static_routing/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── posts/
│ │ │ ├── post1.md
│ │ │ ├── post2.md
│ │ │ ├── post3.md
│ │ │ └── post4.md
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.scss
│ ├── stores/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── subsecond_hot_patch/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── Dioxus.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── assets/
│ │ │ └── main.css
│ │ └── src/
│ │ └── main.rs
│ ├── suspense_tests/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── Cargo.toml
│ │ │ ├── Makefile.toml
│ │ │ ├── README.md
│ │ │ ├── features/
│ │ │ │ ├── check_aria_current.feature
│ │ │ │ ├── check_instrumented.feature
│ │ │ │ ├── check_instrumented_issue_3719.feature
│ │ │ │ ├── check_instrumented_suspense_resource.feature
│ │ │ │ ├── click_inside_component_count.feature
│ │ │ │ ├── click_nested_count.feature
│ │ │ │ ├── click_nested_inside_count.feature
│ │ │ │ ├── click_no_resources_count_1.feature
│ │ │ │ ├── click_no_resources_count_2.feature
│ │ │ │ ├── click_parallel_count_1.feature
│ │ │ │ ├── click_parallel_count_2.feature
│ │ │ │ ├── click_single_count.feature
│ │ │ │ ├── open_app.feature
│ │ │ │ ├── view_inside_component.feature
│ │ │ │ ├── view_nested.feature
│ │ │ │ ├── view_nested_inside.feature
│ │ │ │ ├── view_no_resources.feature
│ │ │ │ ├── view_parallel.feature
│ │ │ │ └── view_single.feature
│ │ │ └── tests/
│ │ │ ├── app_suite.rs
│ │ │ └── fixtures/
│ │ │ ├── action.rs
│ │ │ ├── check.rs
│ │ │ ├── find.rs
│ │ │ ├── mod.rs
│ │ │ └── world/
│ │ │ ├── action_steps.rs
│ │ │ ├── check_steps.rs
│ │ │ └── mod.rs
│ │ └── src/
│ │ ├── app.rs
│ │ ├── instrumented.rs
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── tailwind_actix/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── end2end/
│ │ │ ├── package.json
│ │ │ ├── playwright.config.ts
│ │ │ └── tests/
│ │ │ └── example.spec.ts
│ │ ├── input.css
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── app.rs
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── tailwind_axum/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── end2end/
│ │ │ ├── package.json
│ │ │ ├── playwright.config.ts
│ │ │ └── tests/
│ │ │ └── example.spec.ts
│ │ ├── input.css
│ │ ├── package.json
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── app.rs
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── tailwind_csr/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── Trunk.toml
│ │ ├── end2end/
│ │ │ ├── package.json
│ │ │ ├── playwright.config.ts
│ │ │ └── tests/
│ │ │ └── example.spec.ts
│ │ ├── index.html
│ │ ├── input.css
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── app.rs
│ │ └── main.rs
│ ├── timer/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── todo_app_sqlite/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── Cargo.toml
│ │ │ ├── Makefile.toml
│ │ │ ├── README.md
│ │ │ ├── features/
│ │ │ │ ├── add_todo.feature
│ │ │ │ ├── delete_todo.feature
│ │ │ │ └── open_app.feature
│ │ │ └── tests/
│ │ │ ├── app_suite.rs
│ │ │ └── fixtures/
│ │ │ ├── action.rs
│ │ │ ├── check.rs
│ │ │ ├── find.rs
│ │ │ ├── mod.rs
│ │ │ └── world/
│ │ │ ├── action_steps.rs
│ │ │ ├── check_steps.rs
│ │ │ └── mod.rs
│ │ ├── migrations/
│ │ │ └── 20221118172000_create_todo_table.sql
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ └── todo.rs
│ │ └── style.css
│ ├── todo_app_sqlite_axum/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── Cargo.toml
│ │ │ ├── Makefile.toml
│ │ │ ├── README.md
│ │ │ ├── features/
│ │ │ │ ├── add_todo.feature
│ │ │ │ ├── delete_todo.feature
│ │ │ │ └── open_app.feature
│ │ │ └── tests/
│ │ │ ├── app_suite.rs
│ │ │ └── fixtures/
│ │ │ ├── action.rs
│ │ │ ├── check.rs
│ │ │ ├── find.rs
│ │ │ ├── mod.rs
│ │ │ └── world/
│ │ │ ├── action_steps.rs
│ │ │ ├── check_steps.rs
│ │ │ └── mod.rs
│ │ ├── migrations/
│ │ │ └── 20221118172000_create_todo_table.sql
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── error_template.rs
│ │ │ ├── errors.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ └── todo.rs
│ │ └── style.css
│ ├── todo_app_sqlite_csr/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── Cargo.toml
│ │ │ ├── Makefile.toml
│ │ │ ├── README.md
│ │ │ ├── features/
│ │ │ │ ├── add_todo.feature
│ │ │ │ ├── delete_todo.feature
│ │ │ │ └── open_app.feature
│ │ │ └── tests/
│ │ │ ├── app_suite.rs
│ │ │ └── fixtures/
│ │ │ ├── action.rs
│ │ │ ├── check.rs
│ │ │ ├── find.rs
│ │ │ ├── mod.rs
│ │ │ └── world/
│ │ │ ├── action_steps.rs
│ │ │ ├── check_steps.rs
│ │ │ └── mod.rs
│ │ ├── migrations/
│ │ │ └── 20221118172000_create_todo_table.sql
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── error_template.rs
│ │ │ ├── errors.rs
│ │ │ ├── fallback.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ └── todo.rs
│ │ └── style.css
│ ├── todomvc/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── package.json
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ └── websocket/
│ ├── Cargo.toml
│ ├── LICENSE
│ ├── Makefile.toml
│ ├── README.md
│ ├── e2e/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── features/
│ │ │ ├── echo_client_error.feature
│ │ │ ├── echo_server_error.feature
│ │ │ ├── echo_text.feature
│ │ │ └── open_app.feature
│ │ └── tests/
│ │ ├── app_suite.rs
│ │ └── fixtures/
│ │ ├── action.rs
│ │ ├── check.rs
│ │ ├── find.rs
│ │ ├── mod.rs
│ │ └── world/
│ │ ├── action_steps.rs
│ │ ├── check_steps.rs
│ │ └── mod.rs
│ ├── src/
│ │ ├── lib.rs
│ │ ├── main.rs
│ │ └── websocket.rs
│ └── style.css
├── flake.nix
├── hydration_context/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ └── src/
│ ├── csr.rs
│ ├── hydrate.rs
│ ├── lib.rs
│ └── ssr.rs
├── integrations/
│ ├── actix/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── src/
│ │ │ └── lib.rs
│ │ └── tests/
│ │ └── extract_routes.rs
│ ├── axum/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ └── service.rs
│ │ └── tests/
│ │ ├── axum_integration.rs
│ │ └── service_mode/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.css
│ └── utils/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ └── src/
│ └── lib.rs
├── leptos/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── build.rs
│ ├── src/
│ │ ├── animated_show.rs
│ │ ├── attribute_interceptor.rs
│ │ ├── await_.rs
│ │ ├── children.rs
│ │ ├── component.rs
│ │ ├── error_boundary.rs
│ │ ├── for_loop.rs
│ │ ├── form.rs
│ │ ├── from_form_data.rs
│ │ ├── hydration/
│ │ │ ├── hydration_script.js
│ │ │ ├── island_script.js
│ │ │ ├── islands_routing.js
│ │ │ ├── mod.rs
│ │ │ └── reload_script.js
│ │ ├── into_view.rs
│ │ ├── lib.rs
│ │ ├── logging.rs
│ │ ├── mount.rs
│ │ ├── nonce.rs
│ │ ├── portal.rs
│ │ ├── provider.rs
│ │ ├── show.rs
│ │ ├── show_let.rs
│ │ ├── subsecond.rs
│ │ ├── suspense_component.rs
│ │ ├── text_prop.rs
│ │ └── transition.rs
│ └── tests/
│ ├── pr_4061.rs
│ └── ssr.rs
├── leptos_config/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── src/
│ │ ├── errors.rs
│ │ ├── lib.rs
│ │ └── tests.rs
│ └── tests/
│ └── config.rs
├── leptos_dom/
│ ├── .cargo/
│ │ └── config.toml
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── examples/
│ │ ├── hydration-test/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ ├── test-bench/
│ │ │ ├── Cargo.toml
│ │ │ ├── index.html
│ │ │ └── src/
│ │ │ └── main.rs
│ │ └── view-tests/
│ │ ├── Cargo.toml
│ │ ├── index.html
│ │ └── src/
│ │ └── main.rs
│ └── src/
│ ├── helpers.rs
│ ├── lib.rs
│ ├── logging.rs
│ └── macro_helpers/
│ ├── mod.rs
│ └── tracing_property.rs
├── leptos_hot_reload/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ └── src/
│ ├── diff.rs
│ ├── lib.rs
│ ├── node.rs
│ ├── parsing.rs
│ └── patch.js
├── leptos_macro/
│ ├── .gitignore
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── build.rs
│ ├── example/
│ │ ├── Cargo.toml
│ │ └── src/
│ │ └── lib.rs
│ ├── src/
│ │ ├── component.rs
│ │ ├── lazy.rs
│ │ ├── lib.rs
│ │ ├── memo.rs
│ │ ├── params.rs
│ │ ├── slice.rs
│ │ ├── slot.rs
│ │ └── view/
│ │ ├── component_builder.rs
│ │ ├── mod.rs
│ │ ├── slot_helper.rs
│ │ ├── snapshots/
│ │ │ └── leptos_macro__view__tests__client_template__full_span__counter_component.snap
│ │ └── utils.rs
│ └── tests/
│ ├── component.rs
│ ├── memo/
│ │ ├── red.rs
│ │ └── red.stderr
│ ├── memo.rs
│ ├── params.rs
│ ├── server.rs
│ ├── slice/
│ │ ├── red.rs
│ │ └── red.stderr
│ ├── slice.rs
│ ├── ui/
│ │ ├── component.rs
│ │ ├── component.stderr
│ │ ├── component_absolute.rs
│ │ ├── component_absolute.stderr
│ │ ├── server.rs
│ │ └── server.stderr
│ └── ui.rs
├── leptos_server/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ └── src/
│ ├── action.rs
│ ├── lib.rs
│ ├── local_resource.rs
│ ├── multi_action.rs
│ ├── once_resource.rs
│ ├── resource.rs
│ ├── serializers.rs
│ └── shared.rs
├── meta/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ └── src/
│ ├── body.rs
│ ├── html.rs
│ ├── lib.rs
│ ├── link.rs
│ ├── meta_tags.rs
│ ├── script.rs
│ ├── style.rs
│ ├── stylesheet.rs
│ └── title.rs
├── next_tuple/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── oco/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── or_poisoned/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── projects/
│ ├── README.md
│ ├── bevy3d_ui/
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ └── src/
│ │ ├── demos/
│ │ │ ├── bevydemo1/
│ │ │ │ ├── eventqueue/
│ │ │ │ │ ├── events.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ └── plugin.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── scene.rs
│ │ │ │ └── state.rs
│ │ │ └── mod.rs
│ │ ├── main.rs
│ │ └── routes/
│ │ ├── demo1.rs
│ │ └── mod.rs
│ ├── counter_dwarf_debug/
│ │ ├── .gitignore
│ │ ├── .vscode/
│ │ │ ├── launch.json
│ │ │ └── tasks.json
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── Trunk.toml
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── hexagonal-architecture/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── end2end/
│ │ │ ├── package.json
│ │ │ ├── playwright.config.ts
│ │ │ ├── tests/
│ │ │ │ └── example.spec.ts
│ │ │ └── tsconfig.json
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── config.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ ├── middleware.rs
│ │ │ ├── server_types.rs
│ │ │ ├── trait_impl.rs
│ │ │ ├── traits.rs
│ │ │ └── ui_types.rs
│ │ └── style/
│ │ └── main.scss
│ ├── login_with_token_csr_only/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── api-boundary/
│ │ │ ├── Cargo.toml
│ │ │ ├── Makefile.toml
│ │ │ └── src/
│ │ │ └── lib.rs
│ │ ├── client/
│ │ │ ├── Cargo.toml
│ │ │ ├── Makefile.toml
│ │ │ ├── Trunk.toml
│ │ │ ├── index.html
│ │ │ └── src/
│ │ │ ├── api.rs
│ │ │ ├── components/
│ │ │ │ ├── credentials.rs
│ │ │ │ ├── mod.rs
│ │ │ │ └── navbar.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ └── pages/
│ │ │ ├── home.rs
│ │ │ ├── login.rs
│ │ │ ├── mod.rs
│ │ │ └── register.rs
│ │ └── server/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ └── src/
│ │ ├── adapters.rs
│ │ ├── application.rs
│ │ └── main.rs
│ ├── meilisearch-searchbar/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── data_set.csv
│ │ └── src/
│ │ ├── fallback.rs
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── nginx-mpmc/
│ │ ├── .gitignore
│ │ ├── README.md
│ │ ├── app-1/
│ │ │ ├── .gitignore
│ │ │ ├── Cargo.toml
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── src/
│ │ │ │ ├── app.rs
│ │ │ │ ├── error_template.rs
│ │ │ │ ├── fileserv.rs
│ │ │ │ ├── lib.rs
│ │ │ │ └── main.rs
│ │ │ └── style/
│ │ │ └── main.scss
│ │ ├── app-2/
│ │ │ ├── .gitignore
│ │ │ ├── Cargo.toml
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── src/
│ │ │ │ ├── app.rs
│ │ │ │ ├── error_template.rs
│ │ │ │ ├── fileserv.rs
│ │ │ │ ├── lib.rs
│ │ │ │ └── main.rs
│ │ │ └── style/
│ │ │ └── main.scss
│ │ ├── kill.sh
│ │ ├── nginx.conf
│ │ ├── nginx_linux.conf
│ │ ├── run.sh
│ │ ├── run_linux.sh
│ │ ├── shared-server-1/
│ │ │ ├── .gitignore
│ │ │ ├── Cargo.toml
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── src/
│ │ │ │ ├── lib.rs
│ │ │ │ └── main.rs
│ │ │ └── style/
│ │ │ └── main.scss
│ │ └── shared-server-2/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.scss
│ ├── openapi-openai-api-swagger-ui/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── end2end/
│ │ │ ├── package.json
│ │ │ ├── playwright.config.ts
│ │ │ └── tests/
│ │ │ └── example.spec.ts
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── error_template.rs
│ │ │ ├── fileserv.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ └── open_ai.rs
│ │ └── style/
│ │ └── main.scss
│ ├── ory-kratos/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── app/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ ├── auth/
│ │ │ │ ├── extractors.rs
│ │ │ │ ├── kratos_error.rs
│ │ │ │ ├── kratos_html.rs
│ │ │ │ ├── login.rs
│ │ │ │ ├── logout.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── recovery.rs
│ │ │ │ ├── registration.rs
│ │ │ │ ├── session.rs
│ │ │ │ ├── settings.rs
│ │ │ │ └── verification.rs
│ │ │ ├── database_calls.rs
│ │ │ ├── error_template.rs
│ │ │ ├── lib.rs
│ │ │ └── posts/
│ │ │ ├── create_posts.rs
│ │ │ ├── mod.rs
│ │ │ ├── post.rs
│ │ │ └── posts_page.rs
│ │ ├── docker-compose.yml
│ │ ├── e2e/
│ │ │ ├── Cargo.toml
│ │ │ ├── features/
│ │ │ │ ├── 0_test.feature
│ │ │ │ ├── 1_register.feature
│ │ │ │ ├── 2_login.feature
│ │ │ │ ├── 3_logout.feature
│ │ │ │ ├── 4_recovery.feature
│ │ │ │ ├── 5_settings.feature
│ │ │ │ ├── 6_add_post.feature
│ │ │ │ └── 7_edit_post.feature
│ │ │ └── tests/
│ │ │ ├── app_suite.rs
│ │ │ └── fixtures/
│ │ │ ├── mod.rs
│ │ │ └── steps.rs
│ │ ├── frontend/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── lib.rs
│ │ ├── ids/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── lib.rs
│ │ ├── kratos/
│ │ │ ├── email.schema.json
│ │ │ └── kratos.yaml
│ │ ├── migrations/
│ │ │ ├── 01_create_users.sql
│ │ │ ├── 02_create_posts.sql
│ │ │ └── 03_create_post_permissions.sql
│ │ ├── server/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ ├── extract_session.rs
│ │ │ ├── fileserv.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.scss
│ ├── session_auth_axum/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── flake.nix
│ │ ├── migrations/
│ │ │ └── 20230226000000_create_todo_table.sql
│ │ ├── src/
│ │ │ ├── auth.rs
│ │ │ ├── error_template.rs
│ │ │ ├── errors.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ ├── state.rs
│ │ │ └── todo.rs
│ │ └── style.css
│ ├── sitemap_axum/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── init/
│ │ │ └── schema.sql
│ │ ├── sitemap-index.xml
│ │ ├── sitemap-static.xml
│ │ └── src/
│ │ ├── app.rs
│ │ ├── error_template.rs
│ │ ├── fileserv.rs
│ │ ├── lib.rs
│ │ ├── main.rs
│ │ └── sitemap.rs
│ ├── sso_auth_axum/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── flake.nix
│ │ ├── migrations/
│ │ │ └── 20231217000000_create_tables.sql
│ │ ├── src/
│ │ │ ├── auth.rs
│ │ │ ├── error_template.rs
│ │ │ ├── fallback.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ ├── sign_in_sign_up.rs
│ │ │ └── state.rs
│ │ └── style.css
│ └── tauri-from-scratch/
│ ├── .gitignore
│ ├── Cargo.toml
│ ├── README.md
│ ├── Trunk.toml
│ ├── src-orig/
│ │ ├── Cargo.toml
│ │ ├── index.html
│ │ └── src/
│ │ ├── app.rs
│ │ ├── fallback.rs
│ │ ├── lib.rs
│ │ └── main.rs
│ └── src-tauri/
│ ├── Cargo.toml
│ ├── build.rs
│ ├── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ └── tauri.conf.json
├── reactive_graph/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ ├── build.rs
│ ├── src/
│ │ ├── actions/
│ │ │ ├── action.rs
│ │ │ ├── mod.rs
│ │ │ └── multi_action.rs
│ │ ├── callback.rs
│ │ ├── channel.rs
│ │ ├── computed/
│ │ │ ├── arc_memo.rs
│ │ │ ├── async_derived/
│ │ │ │ ├── arc_async_derived.rs
│ │ │ │ ├── async_derived.rs
│ │ │ │ ├── future_impls.rs
│ │ │ │ ├── inner.rs
│ │ │ │ └── mod.rs
│ │ │ ├── inner.rs
│ │ │ ├── memo.rs
│ │ │ └── selector.rs
│ │ ├── computed.rs
│ │ ├── diagnostics.rs
│ │ ├── effect/
│ │ │ ├── effect.rs
│ │ │ ├── effect_function.rs
│ │ │ ├── immediate.rs
│ │ │ ├── inner.rs
│ │ │ └── render_effect.rs
│ │ ├── effect.rs
│ │ ├── graph/
│ │ │ ├── node.rs
│ │ │ ├── sets.rs
│ │ │ ├── source.rs
│ │ │ └── subscriber.rs
│ │ ├── graph.rs
│ │ ├── into_reactive_value.rs
│ │ ├── lib.rs
│ │ ├── nightly.rs
│ │ ├── owner/
│ │ │ ├── arc_stored_value.rs
│ │ │ ├── arena.rs
│ │ │ ├── arena_item.rs
│ │ │ ├── context.rs
│ │ │ ├── storage.rs
│ │ │ └── stored_value.rs
│ │ ├── owner.rs
│ │ ├── send_wrapper_ext.rs
│ │ ├── serde.rs
│ │ ├── signal/
│ │ │ ├── arc_read.rs
│ │ │ ├── arc_rw.rs
│ │ │ ├── arc_trigger.rs
│ │ │ ├── arc_write.rs
│ │ │ ├── guards.rs
│ │ │ ├── mapped.rs
│ │ │ ├── read.rs
│ │ │ ├── rw.rs
│ │ │ ├── subscriber_traits.rs
│ │ │ ├── trigger.rs
│ │ │ └── write.rs
│ │ ├── signal.rs
│ │ ├── trait_options.rs
│ │ ├── traits.rs
│ │ ├── transition.rs
│ │ └── wrappers.rs
│ └── tests/
│ ├── async_derived.rs
│ ├── cleanup.rs
│ ├── effect.rs
│ ├── effect_immediate.rs
│ ├── memo.rs
│ ├── signal.rs
│ └── watch.rs
├── reactive_stores/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ └── src/
│ ├── arc_field.rs
│ ├── deref.rs
│ ├── field.rs
│ ├── iter.rs
│ ├── keyed.rs
│ ├── len.rs
│ ├── lib.rs
│ ├── option.rs
│ ├── patch.rs
│ ├── path.rs
│ ├── serde.rs
│ ├── slotmap.rs
│ ├── store_field.rs
│ └── subfield.rs
├── reactive_stores_macro/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── router/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── build.rs
│ └── src/
│ ├── components.rs
│ ├── flat_router.rs
│ ├── form.rs
│ ├── generate_route_list.rs
│ ├── hooks.rs
│ ├── lib.rs
│ ├── link.rs
│ ├── location/
│ │ ├── history.rs
│ │ ├── mod.rs
│ │ └── server.rs
│ ├── matching/
│ │ ├── any_choose_view.rs
│ │ ├── choose_view.rs
│ │ ├── horizontal/
│ │ │ ├── mod.rs
│ │ │ ├── param_segments.rs
│ │ │ ├── static_segment.rs
│ │ │ └── tuples.rs
│ │ ├── mod.rs
│ │ ├── nested/
│ │ │ ├── any_nested_match.rs
│ │ │ ├── any_nested_route.rs
│ │ │ ├── mod.rs
│ │ │ └── tuples.rs
│ │ ├── path_segment.rs
│ │ ├── resolve_path.rs
│ │ └── vertical/
│ │ └── mod.rs
│ ├── method.rs
│ ├── navigate.rs
│ ├── nested_router.rs
│ ├── params.rs
│ ├── reactive.rs
│ ├── ssr_mode.rs
│ └── static_routes.rs
├── router_macro/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── src/
│ │ └── lib.rs
│ └── tests/
│ └── path.rs
├── rustfmt.toml
├── scripts/
│ ├── axum_integration_service_mode.bat
│ ├── axum_integration_service_mode.sh
│ ├── bump.sh
│ └── update_nightly.sh
├── server_fn/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── build.rs
│ ├── server_fn_macro_default/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ └── src/
│ │ └── lib.rs
│ ├── src/
│ │ ├── client.rs
│ │ ├── codec/
│ │ │ ├── bitcode.rs
│ │ │ ├── bitcode_serde.rs
│ │ │ ├── cbor.rs
│ │ │ ├── json.rs
│ │ │ ├── mod.rs
│ │ │ ├── msgpack.rs
│ │ │ ├── multipart.rs
│ │ │ ├── patch.rs
│ │ │ ├── post.rs
│ │ │ ├── postcard.rs
│ │ │ ├── put.rs
│ │ │ ├── rkyv.rs
│ │ │ ├── serde_lite.rs
│ │ │ ├── stream.rs
│ │ │ └── url.rs
│ │ ├── error.rs
│ │ ├── lib.rs
│ │ ├── middleware/
│ │ │ └── mod.rs
│ │ ├── redirect.rs
│ │ ├── request/
│ │ │ ├── actix.rs
│ │ │ ├── axum.rs
│ │ │ ├── browser.rs
│ │ │ ├── generic.rs
│ │ │ ├── mod.rs
│ │ │ ├── reqwest.rs
│ │ │ └── spin.rs
│ │ ├── response/
│ │ │ ├── actix.rs
│ │ │ ├── browser.rs
│ │ │ ├── generic.rs
│ │ │ ├── http.rs
│ │ │ ├── mod.rs
│ │ │ └── reqwest.rs
│ │ └── server.rs
│ └── tests/
│ ├── invalid/
│ │ ├── aliased_return_full.rs
│ │ ├── aliased_return_full.stderr
│ │ ├── aliased_return_none.rs
│ │ ├── aliased_return_none.stderr
│ │ ├── aliased_return_part.rs
│ │ ├── aliased_return_part.stderr
│ │ ├── empty_return.rs
│ │ ├── empty_return.stderr
│ │ ├── no_return.rs
│ │ ├── no_return.stderr
│ │ ├── not_async.rs
│ │ ├── not_async.stderr
│ │ ├── not_result.rs
│ │ └── not_result.stderr
│ ├── server_macro.rs
│ └── valid/
│ ├── aliased_return_full.rs
│ ├── aliased_return_none.rs
│ ├── aliased_return_part.rs
│ ├── custom_error_aliased_return_full.rs
│ ├── custom_error_aliased_return_none.rs
│ └── custom_error_aliased_return_part.rs
├── server_fn_macro/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── build.rs
│ └── src/
│ └── lib.rs
└── tachys/
├── Cargo.toml
├── Makefile.toml
├── build.rs
└── src/
├── dom.rs
├── erased.rs
├── html/
│ ├── attribute/
│ │ ├── any_attribute.rs
│ │ ├── aria.rs
│ │ ├── custom.rs
│ │ ├── global.rs
│ │ ├── key.rs
│ │ ├── maybe_next_attr_erasure_macros.rs
│ │ ├── mod.rs
│ │ └── value.rs
│ ├── class.rs
│ ├── directive.rs
│ ├── element/
│ │ ├── custom.rs
│ │ ├── element_ext.rs
│ │ ├── elements.rs
│ │ ├── inner_html.rs
│ │ └── mod.rs
│ ├── event.rs
│ ├── islands.rs
│ ├── mod.rs
│ ├── node_ref.rs
│ ├── property.rs
│ └── style.rs
├── hydration.rs
├── lib.rs
├── mathml/
│ └── mod.rs
├── oco.rs
├── reactive_graph/
│ ├── bind.rs
│ ├── class.rs
│ ├── inner_html.rs
│ ├── mod.rs
│ ├── node_ref.rs
│ ├── owned.rs
│ ├── property.rs
│ ├── style.rs
│ └── suspense.rs
├── renderer/
│ ├── dom.rs
│ ├── mock_dom.rs
│ ├── mod.rs
│ └── sledgehammer.rs
├── ssr/
│ └── mod.rs
├── svg/
│ └── mod.rs
└── view/
├── add_attr.rs
├── any_view.rs
├── either.rs
├── error_boundary.rs
├── fragment.rs
├── iterators.rs
├── keyed.rs
├── mod.rs
├── primitives.rs
├── static_types.rs
├── strings.rs
├── template.rs
└── tuples.rs
================================================
FILE CONTENTS
================================================
================================================
FILE: .config/nextest.toml
================================================
experimental = ["setup-scripts"]
# For tests that need to run one at a time to avoid resource contention from
# parallel execution.
[test-groups]
serial-integration = { max-threads = 1 }
# The built-in `fn build_test_service` in the test runs a single instance of
# `cargo leptos build` guaranteed with `std::sync::Once`. However,
# `cargo-nexttest` does not have the ability to group tests under the same
# process to emulate what `cargo test` does, thus resulting in competing
# `wasm-bindgen` executions that will clobber each other, breaking the tests.
# While serializing the tests was done at one point as a quick workaround,
# using setup-scripts is the better approach.
#
# References:
# - https://github.com/nextest-rs/nextest/issues/27
# - https://github.com/nextest-rs/nextest/issues/209
#
# [[profile.default.overrides]]
# filter = "binary_id(leptos_axum::axum_integration)"
# test-group = "serial-integration"
# Ideally we want this to work to allow for as much as (relatively) cross-
# platform compatibility via cargo, but there doesn't appear to be a way to
# apply environment variables or otherwise set `LEPTOS_OUTPUT_NAME` within
# this section.
#
# ```
# [scripts.setup.axum_integration_service_mode]
# command = ["cargo", "leptos", "--manifest-path", "integrations/axum/tests/service_mode/Cargo.toml", "build"]
#
# [[profile.default.scripts]]
# filter = "binary_id(leptos_axum::axum_integration)"
# setup = ["axum_integration_service_mode"]
# ```
#
# Instead, we have to do the platform specific route...
[scripts.setup.axum_integration_service_mode_sh]
command = ["./scripts/axum_integration_service_mode.sh"]
[scripts.setup.axum_integration_service_mode_bat]
command = ["cmd", "/c", "scripts\\axum_integration_service_mode.bat"]
[[profile.default.scripts]]
platform = { host = "cfg(unix)" }
filter = "binary_id(leptos_axum::axum_integration)"
setup = ["axum_integration_service_mode_sh"]
[[profile.default.scripts]]
platform = { host = "cfg(windows)" }
filter = "binary_id(leptos_axum::axum_integration)"
setup = ["axum_integration_service_mode_bat"]
================================================
FILE: .github/FUNDING.yml
================================================
# These are supported funding model platforms
github: gbj
================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.md
================================================
---
name: Bug report
about: Create a report to help us improve
title: ''
labels: ''
assignees: ''
---
**Describe the bug**
A clear and concise description of what the bug is.
**Leptos Dependencies**
Please copy and paste the Leptos dependencies and features from your `Cargo.toml`.
For example:
```toml
leptos = { version = "0.3", features = ["serde"] }
leptos_axum = { version = "0.3", optional = true }
leptos_meta = { version = "0.3"}
leptos_router = { version = "0.3"}
```
**To Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error
**Screenshots**
If applicable, add screenshots to help explain your problem.
**Next Steps**
- [ ] I will make a PR
- [ ] I would like to make a PR, but need help getting started
- [ ] I want someone else to take the time to fix this
- [ ] This is a low priority for me and is just shared for your information
**Additional context**
Add any other context about the problem here.
================================================
FILE: .github/ISSUE_TEMPLATE/config.yml
================================================
contact_links:
- name: Support or Question
url: https://github.com/leptos-rs/leptos/discussions/new?category=q-a
about: Do you need help figuring out how to do something, or want some help troubleshooting a bug? You can ask in our Discussions section.
- name: Discord Discussions
url: https://discord.gg/YdRAhS7eQB
about: For more informal, real-time conversation and support, you can join our Discord server.
================================================
FILE: .github/ISSUE_TEMPLATE/feature_request.md
================================================
---
name: Feature request
about: Suggest an idea for this project
title: ''
labels: ''
assignees: ''
---
**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
**Describe the solution you'd like**
A clear and concise description of what you want to happen.
**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.
**Additional context**
Add any other context or screenshots about the feature request here.
================================================
FILE: .github/dependabot.yml
================================================
version: 2
updates:
- package-ecosystem: "github-actions"
directory: "/"
schedule:
interval: "weekly"
# Grouping all dependencies in one PR weekly
- package-ecosystem: cargo
directory: "/"
schedule:
interval: weekly
day: monday
open-pull-requests-limit: 1
allow:
- dependency-type: "all"
groups:
rust-dependencies:
patterns:
- "*"
================================================
FILE: .github/workflows/autofix.yml
================================================
name: autofix.ci
on:
pull_request:
# Running this workflow on main branch pushes requires write permission to apply changes.
# Leave it alone for future uses.
# push:
# branches: ["main"]
permissions:
contents: read
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
env:
CARGO_TERM_COLOR: always
RUST_BACKTRACE: 1
DEBIAN_FRONTEND: noninteractive
jobs:
autofix:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6
- uses: actions-rust-lang/setup-rust-toolchain@v1
with: {toolchain: "nightly-2026-02-24", components: "rustfmt, clippy", target: "wasm32-unknown-unknown", rustflags: ""}
- name: Install Glib
run: |
sudo apt-get update
sudo apt-get install -y libglib2.0-dev
- name: Install cargo-all-features
run: cargo install --git https://github.com/sabify/cargo-all-features --branch arbitrary-command-support
- name: Install jq
run: sudo apt-get install jq
- name: Format the workspace
run: cargo fmt --all
- name: Clippy the workspace
run: cargo all-features clippy --allow-dirty --fix --lib --no-deps
- uses: autofix-ci/action@v1.3.3
if: ${{ always() }}
with:
fail-fast: false
================================================
FILE: .github/workflows/ci.yml
================================================
name: CI
on:
push:
branches:
- main
- leptos_0.6
- leptos_0.8
pull_request:
branches:
- main
- leptos_0.6
- leptos_0.8
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
jobs:
get-leptos-changed:
uses: ./.github/workflows/get-leptos-changed.yml
get-leptos-matrix:
uses: ./.github/workflows/get-leptos-matrix.yml
get-example-changed:
uses: ./.github/workflows/get-example-changed.yml
get-examples-matrix:
uses: ./.github/workflows/get-examples-matrix.yml
test-members:
name: CI (members)
needs: [get-leptos-changed, get-leptos-matrix]
if: needs.get-leptos-changed.outputs.leptos_changed == 'true'
strategy:
matrix: ${{ fromJSON(needs.get-leptos-matrix.outputs.matrix) }}
fail-fast: false
uses: ./.github/workflows/run-cargo-make-task.yml
with:
directory: ${{ matrix.directory }}
test-examples:
name: CI (examples)
needs: [test-members, get-examples-matrix]
if: ${{ success() }}
strategy:
matrix: ${{ fromJSON(needs.get-examples-matrix.outputs.matrix) }}
fail-fast: false
uses: ./.github/workflows/run-cargo-make-task.yml
with:
directory: ${{ matrix.directory }}
test-only-examples:
name: CI (examples)
needs: [get-leptos-changed, get-example-changed]
if: needs.get-leptos-changed.outputs.leptos_changed != 'true' && needs.get-example-changed.outputs.example_changed == 'true'
strategy:
matrix: ${{ fromJSON(needs.get-example-changed.outputs.matrix) }}
fail-fast: false
uses: ./.github/workflows/run-cargo-make-task.yml
with:
directory: ${{ matrix.directory }}
semver-check:
name: SemVer check (stable)
needs: [get-leptos-changed, test-members, test-examples]
if: ${{ success() && needs.get-leptos-changed.outputs.leptos_changed == 'true' && !contains(github.event.pull_request.labels.*.name, 'breaking') }}
runs-on: ubuntu-latest
steps:
- name: Install Glib
run: |
sudo apt-get update
sudo apt-get install -y libglib2.0-dev
- name: Checkout
uses: actions/checkout@v6
- name: Semver Checks
uses: obi1kenobi/cargo-semver-checks-action@v2
================================================
FILE: .github/workflows/get-example-changed.yml
================================================
name: Examples Changed Call
on:
workflow_call:
outputs:
example_changed:
description: "Example Changed"
value: ${{ jobs.get-example-changed.outputs.example_changed }}
# This is for test-only-examples workflow in ci.yml
matrix:
description: "Example Changed Directories"
value: ${{ jobs.get-example-changed.outputs.matrix }}
jobs:
get-example-changed:
name: Get Example Changed
runs-on: ubuntu-latest
outputs:
example_changed: ${{ steps.set-example-changed.outputs.example_changed }}
# This is for test-only-examples workflow in ci.yml
matrix: ${{ steps.set-example-changed.outputs.matrix }}
steps:
- name: Checkout
uses: actions/checkout@v6
with:
fetch-depth: 0
- name: Get example files that changed
id: changed-files
uses: tj-actions/changed-files@v47
with:
files: |
examples/**
!examples/cargo-make/**
!examples/Makefile.toml
!examples/*.md
- name: List example files that changed
run: echo '${{ steps.changed-files.outputs.all_changed_files }}'
- name: Install jq
run: sudo apt-get install jq
- name: Set example_changed
id: set-example-changed
run: |
echo "example_changed=${{ steps.changed-files.outputs.any_changed }}" >> "$GITHUB_OUTPUT"
# This is for test-only-examples workflow in ci.yml
echo "matrix={\"directory\": $(echo '${{ steps.changed-files.outputs.all_changed_files }}' | tr ' ' '\n' | awk -F'/' '{print $1 "/" $2}'| sort -u | jq -R -s -c 'split("\n") | .[:-1]')}" >> "$GITHUB_OUTPUT"
================================================
FILE: .github/workflows/get-examples-matrix.yml
================================================
name: Get Examples Matrix Call
on:
workflow_call:
outputs:
matrix:
description: "Matrix"
value: ${{ jobs.create.outputs.matrix }}
jobs:
create:
name: Create Examples Matrix
runs-on: ubuntu-latest
outputs:
matrix: ${{ steps.set-matrix.outputs.matrix }}
env:
# separate examples using "|" (vertical bar) char like "a|b|c".
# cargo-make should be excluded by default.
EXCLUDED_EXAMPLES: cargo-make
steps:
- name: Checkout
uses: actions/checkout@v6
- name: Install jq
run: sudo apt-get install jq
- name: Set Matrix
id: set-matrix
run: |
examples=$(ls -1d examples/*/ |
grep -vE "($EXCLUDED_EXAMPLES)" |
sed 's/\/$//' |
jq -R -s -c 'split("\n")[:-1]')
echo "Example Directories: $examples"
echo "matrix={\"directory\":$examples}" >> "$GITHUB_OUTPUT"
- name: Print Location Info
run: |
echo "Workspace: ${{ github.workspace }}"
pwd
ls | sort -u
================================================
FILE: .github/workflows/get-leptos-changed.yml
================================================
name: Get Leptos Changed Call
on:
workflow_call:
outputs:
leptos_changed:
description: "Leptos Changed"
value: ${{ jobs.create.outputs.leptos_changed }}
jobs:
create:
name: Detect Source Change
runs-on: ubuntu-latest
outputs:
leptos_changed: ${{ steps.set-source-changed.outputs.leptos_changed }}
steps:
- name: Checkout
uses: actions/checkout@v6
with:
fetch-depth: 0
- name: Get source files that changed
id: changed-source
uses: tj-actions/changed-files@v47
with:
files_ignore: |
.*/**/*
cargo-make/**/*
examples/**/*
projects/**/*
benchmarks/**/*
docs/**/*
- name: List source files that changed
run: echo '${{ steps.changed-source.outputs.all_changed_files }}'
- name: Set leptos_changed
id: set-source-changed
run: |
echo "leptos_changed=${{ steps.changed-source.outputs.any_changed }}" >> "$GITHUB_OUTPUT"
================================================
FILE: .github/workflows/get-leptos-matrix.yml
================================================
name: Get Leptos Matrix Call
on:
workflow_call:
outputs:
matrix:
description: "Matrix"
value: ${{ jobs.create.outputs.matrix }}
jobs:
create:
name: Create Leptos Matrix
runs-on: ubuntu-latest
outputs:
matrix: ${{ steps.set-matrix.outputs.matrix }}
steps:
- name: Checkout
uses: actions/checkout@v6
- name: Install jq
run: sudo apt-get install jq
- name: Set Matrix
id: set-matrix
run: |
crates=$(cargo metadata --no-deps --quiet --format-version 1 |
jq -r '.packages[] | select(.name != "workspace") | .manifest_path| rtrimstr("/Cargo.toml")' |
sed "s|$(pwd)/||" |
jq -R -s -c 'split("\n")[:-1]')
echo "Leptos Directories: $crates"
echo "matrix={\"directory\":$crates}" >> "$GITHUB_OUTPUT"
- name: Print Location Info
run: |
echo "Workspace: ${{ github.workspace }}"
pwd
ls | sort -u
================================================
FILE: .github/workflows/publish-book.yml
================================================
name: Deploy book
on:
push:
paths: ["docs/book/**"]
branches:
- main
jobs:
deploy:
runs-on: ubuntu-latest
permissions:
contents: write # To push a branch
pull-requests: write # To create a PR from that branch
steps:
- uses: actions/checkout@v6
with:
fetch-depth: 0
- name: Install mdbook
run: |
mkdir mdbook
curl -sSL https://github.com/rust-lang/mdBook/releases/download/v0.4.27/mdbook-v0.4.27-x86_64-unknown-linux-gnu.tar.gz | tar -xz --directory=./mdbook
echo `pwd`/mdbook >> $GITHUB_PATH
- name: Deploy GitHub Pages
run: |
cd docs/book
mdbook build
git worktree add gh-pages
git config user.name "Deploy book from CI"
git config user.email ""
cd gh-pages
# Delete the ref to avoid keeping history.
git update-ref -d refs/heads/gh-pages
rm -rf *
mv ../book/* .
git add .
git commit -m "Deploy book $GITHUB_SHA to gh-pages"
git push --force --set-upstream origin gh-pages
================================================
FILE: .github/workflows/run-cargo-make-task.yml
================================================
name: Run Task
on:
workflow_call:
inputs:
directory:
required: true
type: string
env:
CARGO_TERM_COLOR: always
CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse
DEBIAN_FRONTEND: noninteractive
RUSTFLAGS: ${{ inputs.erased_mode && '--cfg erase_components' || '' }}
LEPTOS_TAILWIND_VERSION: v4.0.14
LEPTOS_SASS_VERSION: 1.86.0
jobs:
test:
name: "Run (${{ matrix.toolchain }}) (erased_mode: ${{ matrix.erased_mode && 'enabled' || 'disabled' }})"
runs-on: ubuntu-latest
strategy:
matrix:
toolchain: [stable, nightly-2026-02-24]
erased_mode: [true, false]
steps:
- name: Free Disk Space
run: |
echo "Disk space before cleanup:"
df -h
sudo rm -rf /usr/local/.ghcup
sudo rm -rf /opt/hostedtoolcache/CodeQL
sudo rm -rf /usr/local/lib/android
sudo rm -rf /usr/share/dotnet
sudo rm -rf /opt/ghc
sudo rm -rf /usr/local/share/boost
sudo rm -rf /usr/local/lib/node_modules
# following lines currenly not needed as it takes too much time
# the new isolated CI doesn't need much space to test libraries
#
# uncommet only if nneded
#
# sudo apt-get clean
# sudo apt-get purge -y '^ghc-.*' '^dotnet-.*' '^llvm-.*' '^mono-.*' '^php.*' '^ruby.*'
# sudo apt-get autoremove -y
# sudo apt-get clean
# sudo rm -rf "$AGENT_TOOLSDIRECTORY"
# docker system prune -af
# docker image prune -af
# docker volume prune -f
echo "Disk space after cleanup:"
df -h
# Setup environment
- name: Install Glib
run: |
sudo apt-get update
sudo apt-get install -y libglib2.0-dev
- uses: actions/checkout@v6
- name: Setup Rust
uses: dtolnay/rust-toolchain@master
with:
toolchain: ${{ matrix.toolchain }}
targets: wasm32-unknown-unknown
components: clippy,rustfmt
- name: Install binstall
uses: cargo-bins/cargo-binstall@main
- name: Install wasm-bindgen
run: cargo binstall wasm-bindgen-cli --no-confirm
- name: Install cargo-leptos
run: cargo binstall cargo-leptos --locked --no-confirm
- name: Install cargo-make
run: cargo binstall cargo-make --no-confirm
- name: Install nextest
run: cargo binstall cargo-nextest --locked --no-confirm
- name: Install cargo-all-features
run: cargo install cargo-all-features
# Part of direct-minimal-versions check
- name: Install cargo-hack
if: contains(matrix.toolchain, 'nightly')
uses: taiki-e/install-action@cargo-hack
# Part of direct-minimal-versions check
- name: Install cargo-minimal-versions
if: contains(matrix.toolchain, 'nightly')
uses: taiki-e/install-action@cargo-minimal-versions
- name: Install Trunk
if: contains(inputs.directory, 'examples')
run: cargo binstall trunk --no-confirm
- name: Print Trunk Version
if: contains(inputs.directory, 'examples')
run: trunk --version
- name: Install Node.js
if: contains(inputs.directory, 'examples')
uses: actions/setup-node@v6
with:
node-version: 20
- uses: pnpm/action-setup@v4
name: Install pnpm
if: contains(inputs.directory, 'examples')
id: pnpm-install
with:
version: 8
run_install: false
- name: Get pnpm store directory
if: contains(inputs.directory, 'examples')
id: pnpm-cache
run: |
echo "STORE_PATH=$(pnpm store path)" >> $GITHUB_OUTPUT
- uses: actions/cache@v5
if: contains(inputs.directory, 'examples')
name: Setup pnpm cache
with:
path: ${{ steps.pnpm-cache.outputs.STORE_PATH }}
key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
restore-keys: |
${{ runner.os }}-pnpm-store-
- name: Maybe install chromedriver
if: contains(inputs.directory, 'examples')
run: |
project_makefile='${{inputs.directory}}/Makefile.toml'
webdriver_count=$(cat $project_makefile | grep "cargo-make/webdriver.toml" | wc -l)
if [ $webdriver_count -eq 1 ]; then
if ! command -v chromedriver &>/dev/null; then
echo chromedriver required
sudo apt-get update
sudo apt-get install chromium-chromedriver
else
echo chromedriver is already installed
fi
else
echo chromedriver is not required
fi
- name: Maybe install playwright browser dependencies
if: contains(inputs.directory, 'examples')
run: |
for pw_path in $(find '${{inputs.directory}}' -name playwright.config.ts)
do
pw_dir=$(dirname $pw_path)
if [ ! -v $pw_dir ]; then
echo "Playwright required in $pw_dir"
cd $pw_dir
pnpm dlx playwright install --with-deps
else
echo Playwright is not required
fi
done
- name: Install Deno
if: contains(inputs.directory, 'examples')
uses: denoland/setup-deno@v2
with:
deno-version: v1.x
- name: Maybe install gtk-rs dependencies
if: contains(inputs.directory, 'gtk')
run: |
sudo apt-get install -y libglib2.0-dev libgio2.0-cil-dev libgraphene-1.0-dev libcairo2-dev libpango1.0-dev libgtk-4-dev
- name: Install Tailwind and Sass dependencies
if: contains(inputs.directory, 'examples')
run: |
cd '${{ inputs.directory }}'
tailwindcss_version=$(echo "$LEPTOS_TAILWIND_VERSION" | sed 's/^v//')
sass_version="$LEPTOS_SASS_VERSION"
pnpm add "tailwindcss@$tailwindcss_version" "@tailwindcss/cli@$tailwindcss_version" "sass@$sass_version"
echo "Tailwind CSS version:"
./node_modules/.bin/tailwindcss --version
echo "Sass version:"
./node_modules/.bin/sass --version
# Run Cargo Make Task
- name: ${{ inputs.cargo_make_task }}
run: |
cd '${{ inputs.directory }}'
cargo make --no-workspace --profile=github-actions ci
# check the direct-minimal-versions on release
COMMIT_MSG=$(git log -1 --pretty=format:'%s')
# Supports: v1.2.3, v1.2.3-alpha, v1.2.3-beta1, v1.2.3-rc.1, etc.
if [[ "$COMMIT_MSG" =~ ^v[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9]+(\.?[0-9]+)?)?$ ]]; then
cargo make --no-workspace --profile=github-actions check-minimal-versions --direct
fi
# Check if the counter_isomorphic can be built with leptos_debuginfo cfg flag in release mode
- name: ${{ inputs.cargo_make_task }} with --cfg=leptos_debuginfo
if: contains(inputs.directory, 'counter_isomorphic')
run: |
cd '${{ inputs.directory }}'
RUSTFLAGS="$RUSTFLAGS --cfg leptos_debuginfo" cargo leptos build --release
- name: Clean up ${{ inputs.directory }}
if: always()
run: |
cd '${{ inputs.directory }}'
cargo clean || true
rm -rf node_modules || true
================================================
FILE: .gitignore
================================================
target
dist
pkg
comparisons
blob.rs
**/projects/**/Cargo.lock
**/examples/**/Cargo.lock
**/benchmarks/**/Cargo.lock
**/*.rs.bk
.DS_Store
.idea
.direnv
.envrc
.vscode
vendor
hash.txt
================================================
FILE: ARCHITECTURE.md
================================================
# Architecture
The goal of this document is to make it easier for contributors (and anyone
who’s interested!) to understand the architecture of the framework.
The whole Leptos framework is built from a series of layers. Each of these layers
depends on the one below it, but each can be used independently from the ones
built on top of it. While running a command like `cargo leptos new --git
leptos-rs/start` pulls in the whole framework, it’s important to remember that
none of this is magic: each layer of that onion can be stripped away and
reimplemented, configured, or adapted as needed, incrementally.
> Everything that follows will assume you have a good working understanding
> of the framework. There will be explanations of how some parts of it work
> or fit together, but these are not docs. They assume you know what I’m
> talking about.
## The Reactive System: `leptos_reactive`
The reactive system allows you to define dynamic values (signals),
the relationships between them (derived signals and memos), and the side effects
that run in response to them (effects).
These concepts are completely independent of the DOM and can be used to drive
any kind of reactive updates. The reactive system is based on the assumption
that data is relatively cheap, and side effects are relatively expensive. Its
goal is to minimize those side effects (like updating the DOM or making a network
requests) as infrequently as possible.
The reactive system is implemented as a single data structure that exists at
runtime. In exchange for giving ownership over a value to the reactive system
(by creating a signal), you receive a `Copy + 'static` identifier for its
location in the reactive system. This enables most of the ergonomics of storing
and sharing state, the use of callback closures without lifetime issues, etc.
This is implemented by storing signals in a slotmap arena. The signal, memo,
and scope types that are exposed to users simply carry around an index into that
slotmap.
> Items owned by the reactive system are dropped when the corresponding reactive
> scope is dropped, i.e., when the component or section of the UI they’re
> created in is removed. In a sense, Leptos implements a “garbage collector”
> in which the lifetime of data is tied to the lifetime of the UI, not Rust’s
> lexical scopes.
## The DOM Renderer: `leptos_dom`
The reactive system can be used to drive any kinds of side effects. One very
common side effect is calling an imperative method, for example to update the
DOM.
The entire DOM renderer is built on top of the reactive system. It provides
a builder pattern that can be used to create DOM elements dynamically.
The renderer assumes, as a convention, that dynamic attributes, classes,
styles, and children are defined by being passed a `Fn() -> T`, where their
static equivalents just receive `T`. There’s nothing about this that is
divinely ordained, but it’s a useful convention because it allows us to use
zero-overhead derived signals as one of several ways to indicate dynamic
content.
`leptos_dom` also contains code for server-side rendering of the same
UI views to HTML, either for out-of-order streaming (`src/ssr.rs`) or
in-order streaming/async rendering (`src/ssr_in_order.rs`).
## The Macros: `leptos_macro`
It’s entirely possible to write Leptos code with no macros at all. The
`view` and `component` macros, the most common, can be replaced by
the builder syntax and simple functions (see the `counter_without_macros`
example). But the macros enable a JSX-like syntax for describing views.
This package also contains the `Params` derive macro used for typed
queries and route params in the router.
### Macro-based Optimizations
Leptos 0.0.x was built much more heavily on macros. Taking its cues
from SolidJS, the `view` macro emitted different code for CSR, SSR, and
hydration, optimizing each. The CSR/hydrate versions worked by compiling
the view to an HTML template string, cloning that `<template>`, and
traversing the DOM to set up reactivity. The SSR version worked similarly
by compiling the static parts of the view to strings at compile time,
reducing the amount of work that needed to be done on each request.
Proc macros are hard, and this system was brittle. 0.1 introduced a
more robust renderer, including the builder syntax, and rebuilt the `view`
macro to use that builder syntax instead. It moved the optimized-but-buggy
CSR version of the macro to a more-limited `template` macro.
The `view` macro now separately optimizes SSR to use the same static-string
optimizations, which (by our benchmarks) makes Leptos about 3-4x faster
than similar Rust frontend frameworks in its HTML rendering.
> The optimization is pretty straightforward. Consider the following view:
>
> ```rust
> view! { cx,
> <main class="text-center">
> <div class="flex-col">
> <button>"Click me."</button>
> <p class="italic">"Text."</p>
> </div>
> </main>
> }
> ```
>
> Internally, with the builder this is something like
>
> ```rust
> Element {
> tag: "main",
> attrs: vec![("class", "text-center")],
> children: vec![
> Element {
> tag: "div",
> attrs: vec![("class", "flex-col")],
> children: vec![
> Element {
> tag: "button",
> attrs: vec![],
> children: vec!["Click me"]
> },
> Element {
> tag: "p",
> attrs: vec![("class", "italic")],
> children: vec!["Text"]
> }
> ]
> }
> ]
> }
> ```
>
> This is a _bunch_ of small allocations and separate strings,
> and in early 0.1 versions we used a `SmallVec` for children and
> attributes and actually caused some stack overflows.
>
> But if you look at the view itself you can see that none of this
> will _ever_ change. So we can actually optimize it at compile
> time to a single `&'static str`:
>
> ```rust
> r#"<main class="text-center">
> <div class="flex-col">
> <button>"Click me."</button>
> <p class="italic">"Text."</p>
> </div>
> </main>"#
> ```
## Server Functions (`leptos_server`, `server_fn`, and `server_fn_macro`)
Server functions are a framework-agnostic shorthand for converting
a function, whose body can only be run on the server, into an ad hoc
REST API endpoint, and then generating code on the client to call that
endpoint when you call the function.
These are inspired by Solid/Bling’s `server$` functions, and there’s
similar work being done in a number of other JavaScript frameworks.
RPC is not a new idea, but these kinds of server functions may be.
Specifically, by using web standards (defaulting to `POST`/`GET` requests
with URL-encoded form data) they allow easy graceful degradation and the
use of the `<form>` element.
This function is split across three packages so that `server_fn` and
`server_fn_macro` can be used by other frameworks. `leptos_server`
includes some Leptos-specific reactive functionality (like actions).
## `leptos`
This package is built on and reexports most of the layers already
mentioned, and implements a number of control-flow components (`<Show/>`,
`<ErrorBoundary/>`, `<For/>`, `<Suspense/>`, `<Transition/>`) that use
public APIs of the other packages.
This is the main entrypoint for users, but is relatively light itself.
## `leptos_meta`
This package exists to allow you to work with tags normally found in
the `<head>`, from within your components.
It is implemented as a distinct package, rather than part of
`leptos_dom`, on the principle that “what can be implemented in userland,
should be.” The framework can be used without it, so it’s not in core.
## `leptos_router`
The router originates as a direct port of `solid-router`, which is the
origin of most of its terminology, architecture, and route-matching logic.
Subsequent developments (like animated routing, and managing route transitions
given the lack of `useTransition` in Leptos) have caused it to diverge
slightly from Solid’s exact code, but it is still very closely related.
The core principle here is “nested routing,” dividing a single page
into independently-rendered parts. This is described in some detail in the docs.
Like `leptos_meta`, it is implemented as a distinct package, because it
can be replaced with another router or with none. The framework can be used
without it, so it’s not in core.
## Server Integrations
The server integrations are the most “frameworky” layer of the whole framework.
These **do** assume the use of `leptos`, `leptos_router`, and `leptos_meta`.
They specifically draw routing data from `leptos_router`, and inject the
metadata from `leptos_meta` into the `<head>` appropriately.
But of course, if you one day create `leptos-helmet` and `leptos-better-router`,
you can create new server integrations that plug them into the SSR rendering
methods from `leptos_dom` instead. Everything involved is quite modular.
These packages essentially provide helpers that save the templates and user apps
from including a huge amount of boilerplate to connect the various other packages
correctly. Again, early versions of the framework examples are illustrative here
for reference: they include large amounts of manual SSR route handling, etc.
## `cargo-leptos` helpers
`leptos_config` and `leptos_hot_reload` exist to support two different features
of `cargo-leptos`, namely its configuration and its view-patching/hot-reloading
features.
It’s important to say that the main feature `cargo-leptos` remains its ability
to conveniently tie together different build tooling, compiling your app to
WASM for the browser, building the server version, pulling in SASS and
Tailwind, etc. It is an extremely good build tool, not a magic formula. Each
of the examples includes instructions for how to run the examples without
`cargo-leptos`.
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Contributor Covenant Code of Conduct
_This Code of Conduct is based on the [Rust Code of Conduct](https://www.rust-lang.org/policies/code-of-conduct)
and the [Bevy Code of Conduct](https://raw.githubusercontent.com/bevyengine/bevy/main/CODE_OF_CONDUCT.md),
which are adapted from the [Node.js Policy on Trolling](http://blog.izs.me/post/30036893703/policy-on-trolling)
and the [Contributor Covenant](https://www.contributor-covenant.org)._
## Our Pledge
We as members, contributors, and leaders pledge to make participation in our
community a harassment-free experience for everyone, regardless of age, body
size, visible or invisible disability, ethnicity, sex characteristics, gender
identity and expression, level of experience, education, socio-economic status,
nationality, personal appearance, race, religion, or sexual identity
and orientation.
We pledge to act and interact in ways that contribute to an open, welcoming,
diverse, inclusive, and healthy community.
## Our Standards
We are a community of people learning and exploring how to build better web applications
with Rust. When interacting with one another, please remember that there are no experts and there are
no stupid questions. Assume the best in other people's communication, and take a step back if
you find yourself getting defensive.
Please note the following guidelines as well:
* Please avoid using overtly sexual aliases or other nicknames that might detract from a friendly, safe and welcoming environment for all.
* Please be kind and courteous. There’s no need to be mean or rude.
* Respect that people have differences of opinion and that every design or implementation choice carries a trade-off and numerous costs. There is seldom a right answer.
* Please keep unstructured critique to a minimum. If you have solid ideas you want to experiment with, make a fork and see how it works.
* We will exclude you from interaction if you insult, demean or harass anyone. That is not welcome behavior. We interpret the term “harassment” as including the definition in the [Citizen Code of Conduct](https://github.com/stumpsyn/policies/blob/master/citizen_code_of_conduct.md); if you have any lack of clarity about what might be included in that concept, please read their definition. In particular, we don’t tolerate behavior that excludes people in socially marginalized groups.
* Private harassment is also unacceptable. No matter who you are, if you feel you have been or are being harassed or made uncomfortable by a community member, please contact the maintainers immediately. Whether you’re a regular contributor or a newcomer, we care about making this community a safe place for you and we’ve got your back.
* Do not make casual mention of slavery or indentured servitude and/or false comparisons of one's occupation or situation to slavery. Please consider using or asking about alternate terminology when referring to such metaphors in technology.
* Likewise any spamming, trolling, flaming, baiting or other attention-stealing behavior is not welcome.
## Moderation
These are the policies for upholding [our community’s standards of conduct](#our-standards). If you feel that a thread needs moderation, please contact the maintainers.
1. Remarks that violate the community standards of conduct, including hateful, hurtful, oppressive, or exclusionary remarks, are not allowed. (Cursing is allowed, but never targeting another user, and never in a hateful manner).
2. Remarks that maintainers find inappropriate, whether listed in the code of conduct or not, are also not allowed.
3. Maintainers will first respond to such remarks with a warning.
4. If the warning is unheeded, the user will be “kicked,” i.e., kicked out of the communication channel to cool off.
5. If the user comes back and continues to make trouble, they will be banned, i.e., indefinitely excluded.
6. Maintainers may choose at their discretion to un-ban the user if it was a first offense and they offer the offended party a genuine apology.
7. If a maintainer bans someone and you think it was unjustified, please take it up with that maintainer, or with a different maintainer, in private. Complaints about bans in-channel are not allowed.
8. Maintainers are held to a higher standard than other community members. If a maintainer creates an inappropriate situation, they should expect less leeway than others.
The enforcement policies in the code of conduct apply to all official venues, including Discord channels, GitHub repositories, and all other forums.
================================================
FILE: CONTRIBUTING.md
================================================
# Contributing to Leptos
Thanks for your interesting in contributing to Leptos! This is a truly
community-driven framework, and while we have a central maintainer (@gbj)
large parts of the renderer, reactive system, and server integrations have
all been written by other contributors. Contributions are always welcome.
Participation in this community is governed by a [Code of Conduct](./CODE_OF_CONDUCT.md).
Some of the most active conversations around development take place on our
[Discord server](https://discord.gg/YdRAhS7eQB).
This guide seeks to
- describe some of the framework’s values (in a technical, not an ethical, sense)
- provide a high-level overview of how the pieces of the framework fit together
- orient you to the organization of this repository
## Values
Leptos, as a framework, reflects certain technical values:
- **Expose primitives rather than imposing patterns.** Provide building blocks
that users can combine together to build up more complex behavior, rather than
requiring users follow certain templates, file formats, etc. e.g., components
are defined as functions, rather than a bespoke single-file component format.
The reactive system feeds into the rendering system, rather than being defined
by it.
- **Bottom-up over top-down.** If you envision a user’s application as a tree
(like an HTML document), push meaning toward the leaves of the tree. e.g., If data
needs to be loaded, load it in a granular primitive (resources) rather than a
route- or page-level data structure.
- **Performance by default.** When possible, users should only pay for what they
use. e.g., we don’t make all component props reactive by default. This is
because doing so would force the overhead of a reactive prop onto props that don’t
need to be reactive.
- **Full-stack performance.** Performance can’t be limited to a single metric,
whether that’s a DOM rendering benchmark, WASM binary size, or server response
time. Use methods like HTTP streaming and progressive enhancement to enable
applications to load, become interactive, and respond as quickly as possible.
- **Use safe Rust.** There’s no need for `unsafe` Rust in the framework, and
avoiding it at all costs reduces the maintenance and testing burden significantly.
- **Embrace Rust semantics.** Especially in things like UI templating, use Rust
semantics or extend them in a predictable way with control-flow components
rather than overloading the meaning of Rust terms like `if` or `for` in a
framework-specific way.
- **Enhance ergonomics without obfuscating what’s happening.** This is by far
the hardest to achieve. It’s often the case that adding additional layers to
improve DX (like a custom build tool and starter templates) comes across as
“too magic” to some people who haven’t had to build the same things manually.
When possible, make it easier to see how the pieces fit together, without
sacrificing the improved DX.
## Processes
We do not have PR templates or formal processes for approving PRs. But there
are a few guidelines that will make it a better experience for everyone:
- Run `cargo fmt` before submitting your code.
- Keep PRs limited to addressing one feature or one issue, in general. In some
cases (e.g., “reduce allocations in the reactive system”) this may touch a number
of different areas, but is still conceptually one thing.
- If it’s an unsolicited PR not linked to an open issue, please include a
specific explanation for what it’s trying to achieve. For example: “When I
was trying to deploy my app under _circumstances X_, I found that the way
_function Y_ was implemented caused _issue Z_. This PR should fix that by
_solution._”
- Our CI tests every PR against all the existing examples, sometimes requiring
compilation for both server and client side, etc. It’s thorough but slow. If
you want to run CI locally to reduce frustration, you can do that by installing
`cargo-make` and using `cargo make check && cargo make test && cargo make
check-examples`.
## Before Submitting a PR
We have a fairly extensive CI setup that runs both lints (like `rustfmt` and `clippy`)
and tests on PRs. You can run most of these locally if you have `cargo-make` installed.
Note that some of the `rustfmt` settings used require usage of the nightly compiler.
Formatting the code using the stable toolchain may result in a wrong code format and
subsequently CI errors.
Run `cargo +nightly fmt` if you want to keep the stable toolchain active.
You may want to let your IDE automatically use the `+nightly` parameter when a
"format on save" action is used.
If you added an example, make sure to add it to the list in `examples/Makefile.toml`.
From the root directory of the repo, run
- `cargo +nightly fmt`
- `cargo +nightly make check`
- `cargo +nightly make test`
- `cargo +nightly make check-examples`
- `cargo +nightly make --profile=github-actions ci`
If you modified an example:
- `cd examples/your_example`
- `cargo +nightly fmt -- --config-path ../..`
- `cargo +nightly make --profile=github-actions verify-flow`
## Architecture
See [ARCHITECTURE.md](./ARCHITECTURE.md).
================================================
FILE: Cargo.toml
================================================
[workspace]
resolver = "2"
members = [
# utilities
"any_spawner",
"const_str_slice_concat",
"either_of",
"next_tuple",
"oco",
"or_poisoned",
# core
"hydration_context",
"leptos",
"leptos_dom",
"leptos_config",
"leptos_hot_reload",
"leptos_macro",
"leptos_server",
"reactive_graph",
"reactive_stores",
"reactive_stores_macro",
"server_fn",
"server_fn_macro",
"server_fn/server_fn_macro_default",
"tachys",
# integrations
"integrations/actix",
"integrations/axum",
"integrations/utils",
# libraries
"meta",
"router",
"router_macro",
"any_error",
]
exclude = ["benchmarks", "examples", "projects"]
[workspace.package]
edition = "2021"
rust-version = "1.88"
[workspace.dependencies]
# members
throw_error = { path = "./any_error/", version = "0.3.1" }
any_spawner = { path = "./any_spawner/", version = "0.3.0" }
const_str_slice_concat = { path = "./const_str_slice_concat", version = "0.1" }
either_of = { path = "./either_of/", version = "0.1.8" }
hydration_context = { path = "./hydration_context", version = "0.3.0" }
leptos = { path = "./leptos", version = "0.8.17" }
leptos_config = { path = "./leptos_config", version = "0.8.9" }
leptos_dom = { path = "./leptos_dom", version = "0.8.8" }
leptos_hot_reload = { path = "./leptos_hot_reload", version = "0.8.6" }
leptos_integration_utils = { path = "./integrations/utils", version = "0.8.8" }
leptos_macro = { path = "./leptos_macro", version = "0.8.15" }
leptos_router = { path = "./router", version = "0.8.12" }
leptos_router_macro = { path = "./router_macro", version = "0.8.6" }
leptos_server = { path = "./leptos_server", version = "0.8.7" }
leptos_meta = { path = "./meta", version = "0.8.6" }
next_tuple = { path = "./next_tuple", version = "0.1.0" }
oco_ref = { path = "./oco", version = "0.2.1" }
or_poisoned = { path = "./or_poisoned", version = "0.1.0" }
reactive_graph = { path = "./reactive_graph", version = "0.2.13" }
reactive_stores = { path = "./reactive_stores", version = "0.4.2" }
reactive_stores_macro = { path = "./reactive_stores_macro", version = "0.4.1" }
server_fn = { path = "./server_fn", version = "0.8.11" }
server_fn_macro = { path = "./server_fn_macro", version = "0.8.10" }
server_fn_macro_default = { path = "./server_fn/server_fn_macro_default", version = "0.8.5" }
tachys = { path = "./tachys", version = "0.2.14" }
# members deps
async-once-cell = { default-features = false, version = "0.5" }
itertools = { default-features = false, version = "0.14" }
convert_case = { default-features = false, version = "0.11" }
convert_case_extras = { default-features = false, version = "0.2" }
serde_json = { default-features = false, version = "1.0" }
trybuild = { default-features = false, version = "1.0" }
typed-builder = { default-features = false, version = "0.23" }
typed-builder-macro = { default-features = false, version = "0.23" }
thiserror = { default-features = false, version = "2.0" }
wasm-bindgen = { default-features = false, version = "0.2" }
indexmap = { default-features = false, version = "2.13" }
rstml = { default-features = false, version = "0.12" }
rustc_version = { default-features = false, version = "0.4" }
guardian = { default-features = false, version = "1.3" }
rustc-hash = { default-features = false, version = "2.1" }
actix-web = { default-features = false, version = "4.12" }
tracing = { default-features = false, version = "0.1" }
slotmap = { default-features = false, version = "1.1" }
futures = { default-features = false, version = "0.3" }
pin-project-lite = { default-features = false, version = "0.2" }
send_wrapper = { default-features = false, version = "0.6" }
tokio-test = { default-features = false, version = "0.4" }
html-escape = { default-features = false, version = "0.2" }
proc-macro-error2 = { default-features = false, version = "2.0" }
const_format = { default-features = false, version = "0.2" }
gloo-net = { default-features = false, version = "0.6" }
url = { default-features = false, version = "2.5" }
tokio = { default-features = false, version = "1.49" }
base64 = { default-features = false, version = "0.22" }
cfg-if = { default-features = false, version = "1.0" }
wasm-bindgen-futures = { default-features = false, version = "0.4" }
tower = { default-features = false, version = "0.5" }
proc-macro2 = { default-features = false, version = "1.0" }
serde = { default-features = false, version = "1.0" }
parking_lot = { default-features = false, version = "0.12" }
axum = { default-features = false, version = "0.8" }
serde_qs = { default-features = false, version = "0.15" }
syn = { default-features = false, version = "2.0" }
xxhash-rust = { default-features = false, version = "0.8" }
paste = { default-features = false, version = "1.0" }
quote = { default-features = false, version = "1.0" }
web-sys = { default-features = false, version = "0.3" }
js-sys = { default-features = false, version = "0.3" }
rand = { default-features = false, version = "0.9" }
serde-lite = { default-features = false, version = "0.5" }
tokio-tungstenite = { default-features = false, version = "0.28" }
serial_test = { default-features = false, version = "3.3" }
erased = { default-features = false, version = "0.1" }
glib = { default-features = false, version = "0.21" }
async-trait = { default-features = false, version = "0.1" }
anyhow = { default-features = false, version = "1.0" }
walkdir = { default-features = false, version = "2.5" }
actix-ws = { default-features = false, version = "0.3" }
tower-http = { default-features = false, version = "0.6" }
prettyplease = { default-features = false, version = "0.2" }
inventory = { default-features = false, version = "0.3" }
config = { default-features = false, version = "0.15" }
camino = { default-features = false, version = "1.2" }
ciborium = { default-features = false, version = "0.2" }
bitcode = { default-features = false, version = "0.6" }
multer = { default-features = false, version = "3.1" }
leptos-spin-macro = { default-features = false, version = "0.2" }
sledgehammer_utils = { default-features = false, version = "0.3" }
sledgehammer_bindgen = { default-features = false, version = "0.6" }
wasm-streams = { default-features = false, version = "0.5" }
rkyv = { default-features = false, version = "0.8" }
temp-env = { default-features = false, version = "0.3" }
uuid = { default-features = false, version = "1.20" }
bytes = { default-features = false, version = "1.11" }
http = { default-features = false, version = "1.4" }
regex = { default-features = false, version = "1.12" }
drain_filter_polyfill = { default-features = false, version = "0.1" }
tempfile = { default-features = false, version = "3.24" }
futures-lite = { default-features = false, version = "2.6" }
log = { default-features = false, version = "0.4" }
percent-encoding = { default-features = false, version = "2.3" }
async-executor = { default-features = false, version = "1.13" }
const-str = { default-features = false, version = "1.1" }
http-body-util = { default-features = false, version = "0.1" }
hyper = { default-features = false, version = "1.8" }
postcard = { default-features = false, version = "1.1" }
rmp-serde = { default-features = false, version = "1.3" }
reqwest = { default-features = false, version = "0.13" }
tower-layer = { default-features = false, version = "0.3" }
attribute-derive = { default-features = false, version = "0.10" }
insta = { default-features = false, version = "1.46" }
codee = { default-features = false, version = "0.3" }
actix-http = { default-features = false, version = "3.11" }
wasm-bindgen-test = { default-features = false, version = "0.3" }
rustversion = { default-features = false, version = "1.0" }
getrandom = { default-features = false, version = "0.4" }
actix-files = { default-features = false, version = "0.6" }
async-lock = { default-features = false, version = "3.4" }
base16 = { default-features = false, version = "0.2" }
digest = { default-features = false, version = "0.10" }
sha2 = { default-features = false, version = "0.10" }
subsecond = { default-features = false, version = "0.7" }
dioxus-cli-config = { default-features = false, version = "0.7" }
dioxus-devtools = { default-features = false, version = "0.7" }
wasm_split_helpers = { default-features = false, version = "0.2" }
[profile.release]
codegen-units = 1
lto = true
opt-level = 'z'
[workspace.metadata.cargo-all-features]
skip_feature_sets = [["csr", "ssr"], ["csr", "hydrate"], ["ssr", "hydrate"]]
max_combination_size = 2
[workspace.lints.rust]
unexpected_cfgs = { level = "warn", check-cfg = [
'cfg(leptos_debuginfo)',
'cfg(erase_components)',
] }
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) 2022 Greg Johnston
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: Makefile.toml
================================================
############
# A make file for cargo-make, please install it with:
# cargo install --force cargo-make
############
[env]
CARGO_MAKE_EXTEND_WORKSPACE_MAKEFILE = true
[tasks.check-stable]
workspace = false
clear = true
dependencies = [
{ name = "lint", path = "examples/counter_without_macros" },
{ name = "lint", path = "examples/counters_stable" },
]
[tasks.ci-examples]
workspace = false
cwd = "examples"
command = "cargo"
args = ["make", "ci-clean"]
[tasks.check-examples]
workspace = false
cwd = "examples"
command = "cargo"
args = ["make", "check-clean"]
[tasks.build-examples]
workspace = false
cwd = "examples"
command = "cargo"
args = ["make", "build-clean"]
[tasks.clean-examples]
workspace = false
cwd = "examples"
command = "cargo"
args = ["make", "clean"]
================================================
FILE: README.md
================================================
<picture>
<source srcset="https://raw.githubusercontent.com/leptos-rs/leptos/main/docs/logos/Leptos_logo_pref_dark_RGB.svg" media="(prefers-color-scheme: dark)">
<img src="https://raw.githubusercontent.com/leptos-rs/leptos/main/docs/logos/Leptos_logo_RGB.svg" alt="Leptos Logo">
</picture>
[](https://crates.io/crates/leptos)
[](https://docs.rs/leptos)
[](https://discord.gg/YdRAhS7eQB)
[](https://matrix.to/#/#leptos:matrix.org)
[Website](https://leptos.dev) | [Book](https://leptos-rs.github.io/leptos/) | [Docs.rs](https://docs.rs/leptos/latest/leptos/) | [Playground](https://codesandbox.io/p/devbox/playground-j23dz7?file=%2Fsrc%2Fmain.rs) | [Discord](https://discord.gg/YdRAhS7eQB)
You can find a list of useful libraries and example projects at [`awesome-leptos`](https://github.com/leptos-rs/awesome-leptos).
# Leptos
```rust
use leptos::*;
#[component]
pub fn SimpleCounter(initial_value: i32) -> impl IntoView {
// create a reactive signal with the initial value
let (value, set_value) = signal(initial_value);
// create event handlers for our buttons
// note that `value` and `set_value` are `Copy`, so it's super easy to move them into closures
let clear = move |_| set_value(0);
let decrement = move |_| set_value.update(|value| *value -= 1);
let increment = move |_| set_value.update(|value| *value += 1);
// create user interfaces with the declarative `view!` macro
view! {
<div>
<button on:click=clear>Clear</button>
<button on:click=decrement>-1</button>
// text nodes can be quoted or unquoted
<span>"Value: " {value} "!"</span>
<button on:click=increment>+1</button>
</div>
}
}
// we also support a builder syntax rather than the JSX-like `view` macro
#[component]
pub fn SimpleCounterWithBuilder(initial_value: i32) -> impl IntoView {
use leptos::html::*;
let (value, set_value) = signal(initial_value);
let clear = move |_| set_value(0);
let decrement = move |_| set_value.update(|value| *value -= 1);
let increment = move |_| set_value.update(|value| *value += 1);
// the `view` macro above expands to this builder syntax
div().child((
button().on(ev::click, clear).child("Clear"),
button().on(ev::click, decrement).child("-1"),
span().child(("Value: ", value, "!")),
button().on(ev::click, increment).child("+1")
))
}
// Easy to use with Trunk (trunkrs.dev) or with a simple wasm-bindgen setup
pub fn main() {
mount_to_body(|| view! {
<SimpleCounter initial_value=3 />
})
}
```
## About the Framework
Leptos is a full-stack, isomorphic Rust web framework leveraging fine-grained reactivity to build declarative user interfaces.
## What does that mean?
- **Full-stack**: Leptos can be used to build apps that run in the browser (client-side rendering), on the server (server-side rendering), or by rendering HTML on the server and then adding interactivity in the browser (server-side rendering with hydration). This includes support for HTTP streaming of both data ([`Resource`s](https://docs.rs/leptos/latest/leptos/prelude/struct.Resource.html)) and HTML (out-of-order or in-order streaming of [`<Suspense/>`](https://docs.rs/leptos/latest/leptos/suspense/fn.Suspense.html) components.)
- **Isomorphic**: Leptos provides primitives to write isomorphic [server functions](https://docs.rs/server_fn/latest/server_fn/), i.e., functions that can be called with the “same shape” on the client or server, but only run on the server. This means you can write your server-only logic (database requests, authentication etc.) alongside the client-side components that will consume it, and call server functions as if they were running in the browser, without needing to create and maintain a separate REST or other API.
- **Web**: Leptos is built on the Web platform and Web standards. The [router](https://docs.rs/leptos_router/latest/leptos_router/) is designed to use Web fundamentals (like links and forms) and build on top of them rather than trying to replace them.
- **Framework**: Leptos provides most of what you need to build a modern web app: a reactive system, templating library, and a router that works on both the server and client side.
- **Fine-grained reactivity**: The entire framework is built from reactive primitives. This allows for extremely performant code with minimal overhead: when a reactive signal’s value changes, it can update a single text node, toggle a single class, or remove an element from the DOM without any other code running. (So, no virtual DOM overhead!)
- **Declarative**: Tell Leptos how you want the page to look, and let the framework tell the browser how to do it.
## Learn more
Here are some resources for learning more about Leptos:
- [Book](https://leptos-rs.github.io/leptos/) (work in progress)
- [Examples](https://github.com/leptos-rs/leptos/tree/main/examples)
- [API Documentation](https://docs.rs/leptos/latest/leptos/)
- [Common Bugs](https://github.com/leptos-rs/leptos/tree/main/docs/COMMON_BUGS.md) (and how to fix them!)
### Random numbers on wasm (`rand` / `getrandom`)
When you compile a Leptos app to `wasm32-unknown-unknown`, `rand` and `getrandom` need a JavaScript-backed source of randomness. If that backend isn’t enabled, your build can fail or randomness just won’t work in the browser.
Leptos itself takes care of this for its own code, but that does **not** automatically configure your app’s own `rand` / `getrandom` dependencies. If you use them directly, you need to turn on the JS backend yourself.
A simple setup in your `Cargo.toml` might look like this:
```toml
[dependencies]
# Make sure getrandom works on wasm by enabling its JS backend
getrandom = { version = "0.2", features = ["js"] }
rand = { version = "0.8", features = ["small_rng"] }
```
Some of the examples in this repo (for example `js-framework-benchmark` and `hackernews_js_fetch`) already do this, so you can use them as a reference if you’re unsure.
## `cargo-leptos`
[`cargo-leptos`](https://github.com/leptos-rs/cargo-leptos) is a build tool that's designed to make it easy to build apps that run on both the client and the server, with seamless integration. The best way to get started with a real Leptos project right now is to use `cargo-leptos` and our starter templates for [Actix](https://github.com/leptos-rs/start) or [Axum](https://github.com/leptos-rs/start-axum).
```bash
cargo install cargo-leptos --locked
cargo leptos new --git https://github.com/leptos-rs/start-axum
cd [your project name]
cargo leptos watch
```
Open browser to [http://localhost:3000/](http://localhost:3000/).
## FAQs
### What’s up with the name?
_Leptos_ (λεπτός) is an ancient Greek word meaning “thin, light, refined, fine-grained.” To me, a classicist and not a dog owner, it evokes the lightweight reactive system that powers the framework. I've since learned the same word is at the root of the medical term “leptospirosis,” a blood infection that affects humans and animals... My bad. No dogs were harmed in the creation of this framework.
### Is it production ready?
People usually mean one of three things by this question.
1. **Are the APIs stable?** i.e., will I have to rewrite my whole app from Leptos 0.1 to 0.2 to 0.3 to 0.4, or can I write it now and benefit from new features and updates as new versions come?
The APIs are basically settled. We’re adding new features, but we’re very happy with where the type system and patterns have landed. I would not expect major breaking changes to your code to adapt to future releases, in terms of architecture.
2. **Are there bugs?**
Yes, I’m sure there are. You can see from the state of our issue tracker over time that there aren’t that _many_ bugs and they’re usually resolved pretty quickly. But for sure, there may be moments where you encounter something that requires a fix at the framework level, which may not be immediately resolved.
3. **Am I a consumer or a contributor?**
This may be the big one: “production ready” implies a certain orientation to a library: that you can basically use it, without any special knowledge of its internals or ability to contribute. Everyone has this at some level in their stack: for example I (@gbj) don’t have the capacity or knowledge to contribute to something like `wasm-bindgen` at this point: I simply rely on it to work.
There are several people in the community using Leptos right now for many websites at work, who have also become significant contributors. There may be missing features that you need, and you may end up building them! But, if you're willing to contribute a few missing pieces along the way, the framework is most definitely usable for production applications, especially given the ecosystem of libraries that have sprung up around it.
### Can I use this for native GUI?
Sure! Obviously the `view` macro is for generating DOM nodes but you can use the reactive system to drive any native GUI toolkit that uses the same kind of object-oriented, event-callback-based framework as the DOM pretty easily. The principles are the same:
- Use signals, derived signals, and memos to create your reactive system
- Create GUI widgets
- Use event listeners to update signals
- Create effects to update the UI
The 0.7 update originally set out to create a "generic rendering" approach that would allow us to reuse most of the same view logic to do all of the above. Unfortunately, this has had to be shelved for now due to difficulties encountered by the Rust compiler when building larger-scale applications with the number of generics spread throughout the codebase that this required. It's an approach I'm looking forward to exploring again in the future; feel free to reach out if you're interested in this kind of work.
### How is this different from Yew?
Yew is the most-used library for Rust web UI development, but there are several differences between Yew and Leptos, in philosophy, approach, and performance.
- **VDOM vs. fine-grained:** Yew is built on the virtual DOM (VDOM) model: state changes cause components to re-render, generating a new virtual DOM tree. Yew diffs this against the previous VDOM, and applies those patches to the actual DOM. Component functions rerun whenever state changes. Leptos takes an entirely different approach. Components run once, creating (and returning) actual DOM nodes and setting up a reactive system to update those DOM nodes.
- **Performance:** This has huge performance implications: Leptos is simply much faster at both creating and updating the UI than Yew is.
- **Server integration:** Yew was created in an era in which browser-rendered single-page apps (SPAs) were the dominant paradigm. While Leptos supports client-side rendering, it also focuses on integrating with the server side of your application via server functions and multiple modes of serving HTML, including out-of-order streaming.
### How is this different from Dioxus?
Like Leptos, Dioxus is a framework for building UIs using web technologies. However, there are significant differences in approach and features.
- **VDOM vs. fine-grained:** While Dioxus has a performant virtual DOM (VDOM), it still uses coarse-grained/component-scoped reactivity: changing a stateful value reruns the component function and diffs the old UI against the new one. Leptos components use a different mental model, creating (and returning) actual DOM nodes and setting up a reactive system to update those DOM nodes.
- **Web vs. desktop priorities:** Dioxus uses Leptos server functions in its fullstack mode, but does not have the same `<Suspense>`-based support for things like streaming HTML rendering, or share the same focus on holistic web performance. Leptos tends to prioritize holistic web performance (streaming HTML rendering, smaller WASM binary sizes, etc.), whereas Dioxus has an unparalleled experience when building desktop apps, because your application logic runs as a native Rust binary.
### How is this different from Sycamore?
Sycamore and Leptos are both heavily influenced by SolidJS. At this point, Leptos has a larger community and ecosystem and is more actively developed. Other differences:
- **Templating DSLs:** Sycamore uses a custom templating language for its views, while Leptos uses a JSX-like template format.
- **`'static` signals:** One of Leptos’s main innovations was the creation of `Copy + 'static` signals, which have excellent ergonomics. Sycamore is in the process of adopting the same pattern, but this is not yet released.
- **Perseus vs. server functions:** The Perseus metaframework provides an opinionated way to build Sycamore apps that include server functionality. Leptos instead provides primitives like server functions in the core of the framework.
================================================
FILE: SECURITY.md
================================================
# Security Policy
## Reporting a Vulnerability
To report a suspected security issue, please contact security@leptos.dev rather than opening
a public issue.
## Supported Versions
The most-recently-released version of the library is supported with security updates.
For example, if a security issue is discovered that affects 0.3.2 and all later releases,
a 0.4.x patch will be released but a new 0.3.x patch release will not be made. You should
plan to update to the latest version to receive any new features or bugfixes of any kind.
================================================
FILE: TODO.md
================================================
- core examples
- [x] counter
- [x] counters
- [x] fetch
- [x] todomvc
- [x] error_boundary
- [x] parent\_child
- [x] on: on components
- [ ] router
- [ ] slots
- [ ] hackernews
- [ ] counter\_isomorphic
- [ ] todo\_app\_sqlite
- other ssr examples
- [ ] error boundary SSR
- reactivity
- Signal wrappers
- SignalDispose implementations on all Copy types
- untracked access warnings
- ErrorBoundary
- [ ] RenderHtml implementation
- [ ] Separate component?
- Suspense/Transition components?
- callbacks
- unsync StoredValue
- SSR
- escaping HTML correctly (attributes + text nodes)
- router
- nested routes
- trailing slashes
- \_meta package (and use in hackernews)
- integrations
- update tests
- hackernews example
- TODOs
- Suspense/Transition/Await components
- nicer routing components
- async routing (waiting for data to load before navigation)
- `<A>` component
- figure out rebuilding issues: list (needs new signal IDs) vs. regular rebuild
================================================
FILE: any_error/Cargo.toml
================================================
[package]
name = "throw_error"
version = "0.3.1"
authors = ["Greg Johnston"]
license = "MIT"
readme = "../README.md"
repository = "https://github.com/leptos-rs/leptos"
description = "Utilities for wrapping, throwing, and catching errors."
rust-version.workspace = true
edition.workspace = true
[dependencies]
pin-project-lite = { workspace = true, default-features = true }
[dev-dependencies]
anyhow.workspace = true
================================================
FILE: any_error/Makefile.toml
================================================
extend = { path = "../cargo-make/main.toml" }
================================================
FILE: any_error/README.md
================================================
A utility library for wrapping arbitrary errors, and for “throwing” errors in a way
that can be caught by user-defined error hooks.
================================================
FILE: any_error/src/lib.rs
================================================
#![forbid(unsafe_code)]
#![deny(missing_docs)]
//! A utility library for wrapping arbitrary errors, and for “throwing” errors in a way
//! that can be caught by user-defined error hooks.
use std::{
cell::RefCell,
error,
fmt::{self, Display},
future::Future,
ops,
pin::Pin,
sync::Arc,
task::{Context, Poll},
};
/* Wrapper Types */
/// A generic wrapper for any error.
#[derive(Debug, Clone)]
#[repr(transparent)]
pub struct Error(Arc<dyn error::Error + Send + Sync>);
impl Error {
/// Converts the wrapper into the inner reference-counted error.
pub fn into_inner(self) -> Arc<dyn error::Error + Send + Sync> {
Arc::clone(&self.0)
}
}
impl ops::Deref for Error {
type Target = Arc<dyn error::Error + Send + Sync>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.0)
}
}
impl<T> From<T> for Error
where
T: Into<Box<dyn error::Error + Send + Sync + 'static>>,
{
fn from(value: T) -> Self {
Error(Arc::from(value.into()))
}
}
/// Implements behavior that allows for global or scoped error handling.
///
/// This allows for both "throwing" errors to register them, and "clearing" errors when they are no
/// longer valid. This is useful for something like a user interface, in which an error can be
/// "thrown" on some invalid user input, and later "cleared" if the user corrects the input.
/// Keeping a unique identifier for each error allows the UI to be updated accordingly.
pub trait ErrorHook: Send + Sync {
/// Handles the given error, returning a unique identifier.
fn throw(&self, error: Error) -> ErrorId;
/// Clears the error associated with the given identifier.
fn clear(&self, id: &ErrorId);
}
/// A unique identifier for an error. This is returned when you call [`throw`], which calls a
/// global error handler.
#[derive(Debug, PartialEq, Eq, Hash, Clone, Default)]
pub struct ErrorId(usize);
impl Display for ErrorId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
Display::fmt(&self.0, f)
}
}
impl From<usize> for ErrorId {
fn from(value: usize) -> Self {
Self(value)
}
}
thread_local! {
static ERROR_HOOK: RefCell<Option<Arc<dyn ErrorHook>>> = RefCell::new(None);
}
/// Resets the error hook to its previous state when dropped.
pub struct ResetErrorHookOnDrop(Option<Arc<dyn ErrorHook>>);
impl Drop for ResetErrorHookOnDrop {
fn drop(&mut self) {
ERROR_HOOK.with_borrow_mut(|this| *this = self.0.take())
}
}
/// Returns the current error hook.
pub fn get_error_hook() -> Option<Arc<dyn ErrorHook>> {
ERROR_HOOK.with_borrow(Clone::clone)
}
/// Sets the current thread-local error hook, which will be invoked when [`throw`] is called.
pub fn set_error_hook(hook: Arc<dyn ErrorHook>) -> ResetErrorHookOnDrop {
ResetErrorHookOnDrop(
ERROR_HOOK.with_borrow_mut(|this| Option::replace(this, hook)),
)
}
/// Invokes the error hook set by [`set_error_hook`] with the given error.
pub fn throw(error: impl Into<Error>) -> ErrorId {
ERROR_HOOK
.with_borrow(|hook| hook.as_ref().map(|hook| hook.throw(error.into())))
.unwrap_or_default()
}
/// Clears the given error from the current error hook.
pub fn clear(id: &ErrorId) {
ERROR_HOOK
.with_borrow(|hook| hook.as_ref().map(|hook| hook.clear(id)))
.unwrap_or_default()
}
pin_project_lite::pin_project! {
/// A [`Future`] that reads the error hook that is set when it is created, and sets this as the
/// current error hook whenever it is polled.
pub struct ErrorHookFuture<Fut> {
hook: Option<Arc<dyn ErrorHook>>,
#[pin]
inner: Fut
}
}
impl<Fut> ErrorHookFuture<Fut> {
/// Reads the current hook and wraps the given [`Future`], returning a new `Future` that will
/// set the error hook whenever it is polled.
pub fn new(inner: Fut) -> Self {
Self {
hook: ERROR_HOOK.with_borrow(Clone::clone),
inner,
}
}
}
impl<Fut> Future for ErrorHookFuture<Fut>
where
Fut: Future,
{
type Output = Fut::Output;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.project();
let _hook = this
.hook
.as_ref()
.map(|hook| set_error_hook(Arc::clone(hook)));
this.inner.poll(cx)
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::error::Error as StdError;
#[derive(Debug)]
struct MyError;
impl Display for MyError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "MyError")
}
}
impl StdError for MyError {}
#[test]
fn test_from() {
let e = MyError;
let _le = Error::from(e);
let e = "some error".to_string();
let _le = Error::from(e);
let e = anyhow::anyhow!("anyhow error");
let _le = Error::from(e);
}
}
================================================
FILE: any_spawner/Cargo.toml
================================================
[package]
name = "any_spawner"
version = "0.3.0"
authors = ["Greg Johnston"]
license = "MIT"
readme = "../README.md"
repository = "https://github.com/leptos-rs/leptos"
description = "Spawn asynchronous tasks in an executor-independent way."
edition.workspace = true
[dependencies]
async-executor = { optional = true , workspace = true, default-features = true }
futures = { workspace = true, default-features = true }
glib = { optional = true , workspace = true, default-features = true }
thiserror = { workspace = true , default-features = true }
tokio = { optional = true, default-features = false, features = [
"rt",
] , workspace = true }
tracing = { optional = true , workspace = true, default-features = true }
wasm-bindgen-futures = { optional = true , workspace = true, default-features = true }
[dev-dependencies]
futures-lite = { default-features = false , workspace = true }
tokio = { default-features = false, features = [
"rt",
"macros",
"time",
] , workspace = true }
wasm-bindgen-test = { workspace = true, default-features = true }
serial_test = { workspace = true, default-features = true }
[features]
async-executor = ["dep:async-executor"]
tracing = ["dep:tracing"]
tokio = ["dep:tokio"]
glib = ["dep:glib"]
wasm-bindgen = ["dep:wasm-bindgen-futures"]
futures-executor = ["futures/thread-pool", "futures/executor"]
[package.metadata.docs.rs]
all-features = true
rustdoc-args = ["--cfg", "docsrs"]
[package.metadata.cargo-all-features]
denylist = ["tracing"]
max_combination_size = 2
================================================
FILE: any_spawner/Makefile.toml
================================================
extend = [
{ path = "../cargo-make/main.toml" },
{ path = "../cargo-make/wasm-test.toml" },
]
================================================
FILE: any_spawner/README.md
================================================
This crate makes it easier to write asynchronous code that is executor-agnostic, by providing a
utility that can be used to spawn tasks in a variety of executors.
It only supports single executor per program, but that executor can be set at runtime, anywhere
in your crate (or an application that depends on it).
This can be extended to support any executor or runtime that supports spawning [`Future`]s.
This is a least common denominator implementation in many ways. Limitations include:
- setting an executor is a one-time, global action
- no "join handle" or other result is returned from the spawn
- the `Future` must output `()`
```rust
use any_spawner::Executor;
Executor::init_futures_executor()
.expect("executor should only be initialized once");
// spawn a thread-safe Future
Executor::spawn(async { /* ... */ });
// spawn a Future that is !Send
Executor::spawn_local(async { /* ... */ });
```
================================================
FILE: any_spawner/src/lib.rs
================================================
//! This crate makes it easier to write asynchronous code that is executor-agnostic, by providing a
//! utility that can be used to spawn tasks in a variety of executors.
//!
//! It only supports single executor per program, but that executor can be set at runtime, anywhere
//! in your crate (or an application that depends on it).
//!
//! This can be extended to support any executor or runtime that supports spawning [`Future`]s.
//!
//! This is a least common denominator implementation in many ways. Limitations include:
//! - setting an executor is a one-time, global action
//! - no "join handle" or other result is returned from the spawn
//! - the `Future` must output `()`
//!
//! ```no_run
//! use any_spawner::Executor;
//!
//! // make sure an Executor has been initialized with one of the init_ functions
//!
//! // spawn a thread-safe Future
//! Executor::spawn(async { /* ... */ });
//!
//! // spawn a Future that is !Send
//! Executor::spawn_local(async { /* ... */ });
//! ```
#![forbid(unsafe_code)]
#![deny(missing_docs)]
#![cfg_attr(docsrs, feature(doc_cfg))]
use std::{future::Future, pin::Pin, sync::OnceLock};
use thiserror::Error;
/// A future that has been pinned.
pub type PinnedFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
/// A future that has been pinned.
pub type PinnedLocalFuture<T> = Pin<Box<dyn Future<Output = T>>>;
// Type alias for the spawn function pointer.
type SpawnFn = fn(PinnedFuture<()>);
// Type alias for the spawn_local function pointer.
type SpawnLocalFn = fn(PinnedLocalFuture<()>);
// Type alias for the poll_local function pointer.
type PollLocalFn = fn();
/// Holds the function pointers for the current global executor.
#[derive(Clone, Copy)]
struct ExecutorFns {
spawn: SpawnFn,
spawn_local: SpawnLocalFn,
poll_local: PollLocalFn,
}
// Use a single OnceLock to ensure atomic initialization of all functions.
static EXECUTOR_FNS: OnceLock<ExecutorFns> = OnceLock::new();
// No-op functions to use when an executor doesn't support a specific operation.
#[cfg(any(feature = "tokio", feature = "wasm-bindgen", feature = "glib"))]
#[cold]
#[inline(never)]
fn no_op_poll() {}
#[cfg(all(not(feature = "wasm-bindgen"), not(debug_assertions)))]
#[cold]
#[inline(never)]
fn no_op_spawn(_: PinnedFuture<()>) {
#[cfg(debug_assertions)]
eprintln!(
"Warning: Executor::spawn called, but no global 'spawn' function is \
configured (perhaps only spawn_local is supported, e.g., on wasm \
without threading?)."
);
}
// Wasm panics if you spawn without an executor
#[cfg(feature = "wasm-bindgen")]
#[cold]
#[inline(never)]
fn no_op_spawn(_: PinnedFuture<()>) {
panic!(
"Executor::spawn called, but no global 'spawn' function is configured."
);
}
#[cfg(not(debug_assertions))]
#[cold]
#[inline(never)]
fn no_op_spawn_local(_: PinnedLocalFuture<()>) {
panic!(
"Executor::spawn_local called, but no global 'spawn_local' function \
is configured."
);
}
/// Errors that can occur when using the executor.
#[derive(Error, Debug)]
pub enum ExecutorError {
/// The executor has already been set.
#[error("Global executor has already been set.")]
AlreadySet,
}
/// A global async executor that can spawn tasks.
pub struct Executor;
impl Executor {
/// Spawns a thread-safe [`Future`].
///
/// Uses the globally configured executor.
/// Panics if no global executor has been initialized.
#[inline(always)]
#[track_caller]
pub fn spawn(fut: impl Future<Output = ()> + Send + 'static) {
let pinned_fut = Box::pin(fut);
if let Some(fns) = EXECUTOR_FNS.get() {
(fns.spawn)(pinned_fut)
} else {
// No global executor set.
handle_uninitialized_spawn(pinned_fut);
}
}
/// Spawns a [`Future`] that cannot be sent across threads.
///
/// Uses the globally configured executor.
/// Panics if no global executor has been initialized.
#[inline(always)]
#[track_caller]
pub fn spawn_local(fut: impl Future<Output = ()> + 'static) {
let pinned_fut = Box::pin(fut);
if let Some(fns) = EXECUTOR_FNS.get() {
(fns.spawn_local)(pinned_fut)
} else {
// No global executor set.
handle_uninitialized_spawn_local(pinned_fut);
}
}
/// Waits until the next "tick" of the current async executor.
/// Respects the global executor.
#[inline(always)]
pub async fn tick() {
let (tx, rx) = futures::channel::oneshot::channel();
#[cfg(not(all(feature = "wasm-bindgen", target_family = "wasm")))]
Executor::spawn(async move {
_ = tx.send(());
});
#[cfg(all(feature = "wasm-bindgen", target_family = "wasm"))]
Executor::spawn_local(async move {
_ = tx.send(());
});
_ = rx.await;
}
/// Polls the global async executor.
///
/// Uses the globally configured executor.
/// Does nothing if the global executor does not support polling.
#[inline(always)]
pub fn poll_local() {
if let Some(fns) = EXECUTOR_FNS.get() {
(fns.poll_local)()
}
// If not initialized or doesn't support polling, do nothing gracefully.
}
}
impl Executor {
/// Globally sets the [`tokio`] runtime as the executor used to spawn tasks.
///
/// Returns `Err(_)` if a global executor has already been set.
///
/// Requires the `tokio` feature to be activated on this crate.
#[cfg(feature = "tokio")]
#[cfg_attr(docsrs, doc(cfg(feature = "tokio")))]
pub fn init_tokio() -> Result<(), ExecutorError> {
let executor_impl = ExecutorFns {
spawn: |fut| {
tokio::spawn(fut);
},
spawn_local: |fut| {
tokio::task::spawn_local(fut);
},
// Tokio doesn't have an explicit global poll function like LocalPool::run_until_stalled
poll_local: no_op_poll,
};
EXECUTOR_FNS
.set(executor_impl)
.map_err(|_| ExecutorError::AlreadySet)
}
/// Globally sets the [`wasm-bindgen-futures`] runtime as the executor used to spawn tasks.
///
/// Returns `Err(_)` if a global executor has already been set.
///
/// Requires the `wasm-bindgen` feature to be activated on this crate.
#[cfg(feature = "wasm-bindgen")]
#[cfg_attr(docsrs, doc(cfg(feature = "wasm-bindgen")))]
pub fn init_wasm_bindgen() -> Result<(), ExecutorError> {
let executor_impl = ExecutorFns {
// wasm-bindgen-futures only supports spawn_local
spawn: no_op_spawn,
spawn_local: |fut| {
wasm_bindgen_futures::spawn_local(fut);
},
poll_local: no_op_poll,
};
EXECUTOR_FNS
.set(executor_impl)
.map_err(|_| ExecutorError::AlreadySet)
}
/// Globally sets the [`glib`] runtime as the executor used to spawn tasks.
///
/// Returns `Err(_)` if a global executor has already been set.
///
/// Requires the `glib` feature to be activated on this crate.
#[cfg(feature = "glib")]
#[cfg_attr(docsrs, doc(cfg(feature = "glib")))]
pub fn init_glib() -> Result<(), ExecutorError> {
let executor_impl = ExecutorFns {
spawn: |fut| {
let main_context = glib::MainContext::default();
main_context.spawn(fut);
},
spawn_local: |fut| {
let main_context = glib::MainContext::default();
main_context.spawn_local(fut);
},
// Glib needs event loop integration, explicit polling isn't the standard model here.
poll_local: no_op_poll,
};
EXECUTOR_FNS
.set(executor_impl)
.map_err(|_| ExecutorError::AlreadySet)
}
/// Globally sets the [`futures`] executor as the executor used to spawn tasks,
/// lazily creating a thread pool to spawn tasks into.
///
/// Returns `Err(_)` if a global executor has already been set.
///
/// Requires the `futures-executor` feature to be activated on this crate.
#[cfg(feature = "futures-executor")]
#[cfg_attr(docsrs, doc(cfg(feature = "futures-executor")))]
pub fn init_futures_executor() -> Result<(), ExecutorError> {
use futures::{
executor::{LocalPool, LocalSpawner, ThreadPool},
task::{LocalSpawnExt, SpawnExt},
};
use std::cell::RefCell;
// Keep the lazy-init ThreadPool and thread-local LocalPool for spawn_local impl
static THREAD_POOL: OnceLock<ThreadPool> = OnceLock::new();
thread_local! {
static LOCAL_POOL: RefCell<LocalPool> = RefCell::new(LocalPool::new());
// SPAWNER is derived from LOCAL_POOL, keep it for efficiency inside the closure
static SPAWNER: LocalSpawner = LOCAL_POOL.with(|pool| pool.borrow().spawner());
}
fn get_thread_pool() -> &'static ThreadPool {
THREAD_POOL.get_or_init(|| {
ThreadPool::new()
.expect("could not create futures executor ThreadPool")
})
}
let executor_impl = ExecutorFns {
spawn: |fut| {
get_thread_pool()
.spawn(fut)
.expect("failed to spawn future on ThreadPool");
},
spawn_local: |fut| {
// Use the thread_local SPAWNER derived from LOCAL_POOL
SPAWNER.with(|spawner| {
spawner
.spawn_local(fut)
.expect("failed to spawn local future");
});
},
poll_local: || {
// Use the thread_local LOCAL_POOL
LOCAL_POOL.with(|pool| {
// Use try_borrow_mut to prevent panic during re-entrant calls
if let Ok(mut pool) = pool.try_borrow_mut() {
pool.run_until_stalled();
}
// If already borrowed, we're likely in a nested poll, so do nothing.
});
},
};
EXECUTOR_FNS
.set(executor_impl)
.map_err(|_| ExecutorError::AlreadySet)
}
/// Globally sets the [`async_executor`] executor as the executor used to spawn tasks,
/// lazily creating a thread pool to spawn tasks into.
///
/// Returns `Err(_)` if a global executor has already been set.
///
/// Requires the `async-executor` feature to be activated on this crate.
#[cfg(feature = "async-executor")]
#[cfg_attr(docsrs, doc(cfg(feature = "async-executor")))]
pub fn init_async_executor() -> Result<(), ExecutorError> {
use async_executor::{Executor as AsyncExecutor, LocalExecutor};
// Keep the lazy-init global Executor and thread-local LocalExecutor for spawn_local impl
static ASYNC_EXECUTOR: OnceLock<AsyncExecutor<'static>> =
OnceLock::new();
thread_local! {
static LOCAL_EXECUTOR_POOL: LocalExecutor<'static> = const { LocalExecutor::new() };
}
fn get_async_executor() -> &'static AsyncExecutor<'static> {
ASYNC_EXECUTOR.get_or_init(AsyncExecutor::new)
}
let executor_impl = ExecutorFns {
spawn: |fut| {
get_async_executor().spawn(fut).detach();
},
spawn_local: |fut| {
LOCAL_EXECUTOR_POOL.with(|pool| pool.spawn(fut).detach());
},
poll_local: || {
LOCAL_EXECUTOR_POOL.with(|pool| {
// try_tick polls the local executor without blocking
// This prevents issues if called recursively or from within a task.
pool.try_tick();
});
},
};
EXECUTOR_FNS
.set(executor_impl)
.map_err(|_| ExecutorError::AlreadySet)
}
/// Globally sets a custom executor as the executor used to spawn tasks.
///
/// Requires the custom executor to be `Send + Sync` as it will be stored statically.
///
/// Returns `Err(_)` if a global executor has already been set.
pub fn init_custom_executor(
custom_executor: impl CustomExecutor + Send + Sync + 'static,
) -> Result<(), ExecutorError> {
// Store the custom executor instance itself to call its methods.
// Use Box for dynamic dispatch.
static CUSTOM_EXECUTOR_INSTANCE: OnceLock<
Box<dyn CustomExecutor + Send + Sync>,
> = OnceLock::new();
CUSTOM_EXECUTOR_INSTANCE
.set(Box::new(custom_executor))
.map_err(|_| ExecutorError::AlreadySet)?;
// Now set the ExecutorFns using the stored instance
let executor_impl = ExecutorFns {
spawn: |fut| {
// Unwrap is safe because we just set it successfully or returned Err.
CUSTOM_EXECUTOR_INSTANCE.get().unwrap().spawn(fut);
},
spawn_local: |fut| {
CUSTOM_EXECUTOR_INSTANCE.get().unwrap().spawn_local(fut);
},
poll_local: || {
CUSTOM_EXECUTOR_INSTANCE.get().unwrap().poll_local();
},
};
EXECUTOR_FNS
.set(executor_impl)
.map_err(|_| ExecutorError::AlreadySet)
// If setting EXECUTOR_FNS fails (extremely unlikely race if called *concurrently*
// with another init_* after CUSTOM_EXECUTOR_INSTANCE was set), we technically
// leave CUSTOM_EXECUTOR_INSTANCE set but EXECUTOR_FNS not. This is an edge case,
// but the primary race condition is solved.
}
/// Sets a custom executor *for the current thread only*.
///
/// This overrides the global executor for calls to `spawn`, `spawn_local`, and `poll_local`
/// made *from the current thread*. It does not affect other threads or the global state.
///
/// The provided `custom_executor` must implement [`CustomExecutor`] and `'static`, but does
/// **not** need to be `Send` or `Sync`.
///
/// Returns `Err(ExecutorError::AlreadySet)` if a *local* executor has already been set
/// *for this thread*.
pub fn init_local_custom_executor(
custom_executor: impl CustomExecutor + 'static,
) -> Result<(), ExecutorError> {
// Store the custom executor instance itself to call its methods.
// Use Box for dynamic dispatch.
thread_local! {
static CUSTOM_EXECUTOR_INSTANCE: OnceLock<
Box<dyn CustomExecutor>,
> = OnceLock::new();
};
CUSTOM_EXECUTOR_INSTANCE.with(|this| {
this.set(Box::new(custom_executor))
.map_err(|_| ExecutorError::AlreadySet)
})?;
// Now set the ExecutorFns using the stored instance
let executor_impl = ExecutorFns {
spawn: |fut| {
// Unwrap is safe because we just set it successfully or returned Err.
CUSTOM_EXECUTOR_INSTANCE
.with(|this| this.get().unwrap().spawn(fut));
},
spawn_local: |fut| {
CUSTOM_EXECUTOR_INSTANCE
.with(|this| this.get().unwrap().spawn_local(fut));
},
poll_local: || {
CUSTOM_EXECUTOR_INSTANCE
.with(|this| this.get().unwrap().poll_local());
},
};
EXECUTOR_FNS
.set(executor_impl)
.map_err(|_| ExecutorError::AlreadySet)
}
}
/// A trait for custom executors.
/// Custom executors can be used to integrate with any executor that supports spawning futures.
///
/// If used with `init_custom_executor`, the implementation must be `Send + Sync + 'static`.
///
/// All methods can be called recursively. Implementors should be mindful of potential
/// deadlocks or excessive resource consumption if recursive calls are not handled carefully
/// (e.g., using `try_borrow_mut` or non-blocking polls within implementations).
pub trait CustomExecutor {
/// Spawns a future, usually on a thread pool.
fn spawn(&self, fut: PinnedFuture<()>);
/// Spawns a local future. May require calling `poll_local` to make progress.
fn spawn_local(&self, fut: PinnedLocalFuture<()>);
/// Polls the executor, if it supports polling. Implementations should ideally be
/// non-blocking or use mechanisms like `try_tick` or `try_borrow_mut` to handle
/// re-entrant calls safely.
fn poll_local(&self);
}
// Ensure CustomExecutor is object-safe
#[allow(dead_code)]
fn test_object_safety(_: Box<dyn CustomExecutor + Send + Sync>) {} // Added Send + Sync constraint here for global usage
/// Handles the case where `Executor::spawn` is called without an initialized executor.
#[cold] // Less likely path
#[inline(never)]
#[track_caller]
fn handle_uninitialized_spawn(_fut: PinnedFuture<()>) {
let caller = std::panic::Location::caller();
#[cfg(all(debug_assertions, feature = "tracing"))]
{
tracing::error!(
target: "any_spawner",
spawn_caller=%caller,
"Executor::spawn called before a global executor was initialized. Task dropped."
);
// Drop the future implicitly after logging
drop(_fut);
}
#[cfg(all(debug_assertions, not(feature = "tracing")))]
{
panic!(
"At {caller}, tried to spawn a Future with Executor::spawn() \
before a global executor was initialized."
);
}
// In release builds (without tracing), call the specific no-op function.
#[cfg(not(debug_assertions))]
{
no_op_spawn(_fut);
}
}
/// Handles the case where `Executor::spawn_local` is called without an initialized executor.
#[cold] // Less likely path
#[inline(never)]
#[track_caller]
fn handle_uninitialized_spawn_local(_fut: PinnedLocalFuture<()>) {
let caller = std::panic::Location::caller();
#[cfg(all(debug_assertions, feature = "tracing"))]
{
tracing::error!(
target: "any_spawner",
spawn_caller=%caller,
"Executor::spawn_local called before a global executor was initialized. \
Task likely dropped or panicked."
);
// Fall through to panic or no-op depending on build/target
}
#[cfg(all(debug_assertions, not(feature = "tracing")))]
{
panic!(
"At {caller}, tried to spawn a Future with \
Executor::spawn_local() before a global executor was initialized."
);
}
// In release builds (without tracing), call the specific no-op function (which usually panics).
#[cfg(not(debug_assertions))]
{
no_op_spawn_local(_fut);
}
}
================================================
FILE: any_spawner/tests/already_set_error.rs
================================================
use any_spawner::{Executor, ExecutorError};
#[test]
fn test_already_set_error() {
struct SimpleExecutor;
impl any_spawner::CustomExecutor for SimpleExecutor {
fn spawn(&self, _fut: any_spawner::PinnedFuture<()>) {}
fn spawn_local(&self, _fut: any_spawner::PinnedLocalFuture<()>) {}
fn poll_local(&self) {}
}
// First initialization should succeed
Executor::init_custom_executor(SimpleExecutor)
.expect("First initialization failed");
// Second initialization should fail with AlreadySet error
let result = Executor::init_custom_executor(SimpleExecutor);
assert!(matches!(result, Err(ExecutorError::AlreadySet)));
// First local initialization should fail
let result = Executor::init_local_custom_executor(SimpleExecutor);
assert!(matches!(result, Err(ExecutorError::AlreadySet)));
}
================================================
FILE: any_spawner/tests/async_executor.rs
================================================
#![cfg(feature = "async-executor")]
use std::{
future::Future,
pin::Pin,
sync::{Arc, Mutex},
};
// A simple async executor for testing
struct TestExecutor {
tasks: Mutex<Vec<Pin<Box<dyn Future<Output = ()> + Send + 'static>>>>,
}
impl TestExecutor {
fn new() -> Self {
TestExecutor {
tasks: Mutex::new(Vec::new()),
}
}
fn spawn<F>(&self, future: F)
where
F: Future<Output = ()> + Send + 'static,
{
self.tasks.lock().unwrap().push(Box::pin(future));
}
fn run_all(&self) {
// Take all tasks out to process them
let tasks = self.tasks.lock().unwrap().drain(..).collect::<Vec<_>>();
// Use a basic future executor to run each task to completion
for mut task in tasks {
// Use futures-lite's block_on to complete the future
futures::executor::block_on(async {
unsafe {
let task_mut = Pin::new_unchecked(&mut task);
let _ = std::future::Future::poll(
task_mut,
&mut std::task::Context::from_waker(
futures::task::noop_waker_ref(),
),
);
}
});
}
}
}
#[test]
fn test_async_executor() {
let executor = Arc::new(TestExecutor::new());
let executor_clone = executor.clone();
// Create a spawner function that will use our test executor
let spawner = move |future| {
executor_clone.spawn(future);
};
// Prepare test data
let counter = Arc::new(Mutex::new(0));
let counter_clone = counter.clone();
// Use the spawner to spawn a task
spawner(async move {
*counter_clone.lock().unwrap() += 1;
});
// Run all tasks
executor.run_all();
// Check if the task completed correctly
assert_eq!(*counter.lock().unwrap(), 1);
}
================================================
FILE: any_spawner/tests/custom_executor.rs
================================================
use any_spawner::Executor;
use std::sync::{
atomic::{AtomicBool, Ordering},
Arc,
};
#[test]
fn test_custom_executor() {
// Define a simple custom executor
struct TestExecutor {
spawn_called: Arc<AtomicBool>,
spawn_local_called: Arc<AtomicBool>,
poll_local_called: Arc<AtomicBool>,
}
impl any_spawner::CustomExecutor for TestExecutor {
fn spawn(&self, fut: any_spawner::PinnedFuture<()>) {
self.spawn_called.store(true, Ordering::SeqCst);
// Execute the future immediately (this works for simple test futures)
futures::executor::block_on(fut);
}
fn spawn_local(&self, fut: any_spawner::PinnedLocalFuture<()>) {
self.spawn_local_called.store(true, Ordering::SeqCst);
// Execute the future immediately
futures::executor::block_on(fut);
}
fn poll_local(&self) {
self.poll_local_called.store(true, Ordering::SeqCst);
}
}
let spawn_called = Arc::new(AtomicBool::new(false));
let spawn_local_called = Arc::new(AtomicBool::new(false));
let poll_local_called = Arc::new(AtomicBool::new(false));
let executor = TestExecutor {
spawn_called: spawn_called.clone(),
spawn_local_called: spawn_local_called.clone(),
poll_local_called: poll_local_called.clone(),
};
// Initialize with our custom executor
Executor::init_custom_executor(executor)
.expect("Failed to initialize custom executor");
// Test spawn
Executor::spawn(async {
// Simple task
});
assert!(spawn_called.load(Ordering::SeqCst));
// Test spawn_local
Executor::spawn_local(async {
// Simple local task
});
assert!(spawn_local_called.load(Ordering::SeqCst));
// Test poll_local
Executor::poll_local();
assert!(poll_local_called.load(Ordering::SeqCst));
}
================================================
FILE: any_spawner/tests/custom_runtime.rs
================================================
#![cfg(feature = "futures-executor")]
use any_spawner::{CustomExecutor, Executor, PinnedFuture, PinnedLocalFuture};
#[test]
fn can_create_custom_executor() {
use futures::{
executor::{LocalPool, LocalSpawner},
task::LocalSpawnExt,
};
use std::{
cell::RefCell,
sync::{
atomic::{AtomicUsize, Ordering},
Arc,
},
};
thread_local! {
static LOCAL_POOL: RefCell<LocalPool> = RefCell::new(LocalPool::new());
static SPAWNER: LocalSpawner = LOCAL_POOL.with(|pool| pool.borrow().spawner());
}
struct CustomFutureExecutor;
impl CustomExecutor for CustomFutureExecutor {
fn spawn(&self, _fut: PinnedFuture<()>) {
panic!("not supported in this test");
}
fn spawn_local(&self, fut: PinnedLocalFuture<()>) {
SPAWNER.with(|spawner| {
spawner.spawn_local(fut).expect("failed to spawn future");
});
}
fn poll_local(&self) {
LOCAL_POOL.with(|pool| {
if let Ok(mut pool) = pool.try_borrow_mut() {
pool.run_until_stalled();
}
// If we couldn't borrow_mut, we're in a nested call to poll, so we don't need to do anything.
});
}
}
Executor::init_custom_executor(CustomFutureExecutor)
.expect("couldn't set executor");
let counter = Arc::new(AtomicUsize::new(0));
let counter_clone = Arc::clone(&counter);
Executor::spawn_local(async move {
counter_clone.store(1, Ordering::Release);
});
Executor::poll_local();
assert_eq!(counter.load(Ordering::Acquire), 1);
}
================================================
FILE: any_spawner/tests/executor_tick.rs
================================================
#![cfg(feature = "tokio")]
use any_spawner::Executor;
use std::{
sync::{Arc, Mutex},
time::Duration,
};
#[tokio::test]
async fn test_executor_tick() {
// Initialize the tokio executor
Executor::init_tokio().expect("Failed to initialize tokio executor");
let value = Arc::new(Mutex::new(false));
let value_clone = value.clone();
// Spawn a task that sets the value after a tick
Executor::spawn(async move {
Executor::tick().await;
*value_clone.lock().unwrap() = true;
});
// Allow some time for the task to complete
tokio::time::sleep(Duration::from_millis(50)).await;
// Check that the value was set
assert!(*value.lock().unwrap());
}
================================================
FILE: any_spawner/tests/futures_executor.rs
================================================
#![cfg(feature = "futures-executor")]
use any_spawner::Executor;
use futures::channel::oneshot;
use std::{
sync::{Arc, Mutex},
time::Duration,
};
#[test]
fn test_futures_executor() {
// Initialize the futures executor
Executor::init_futures_executor()
.expect("Failed to initialize futures executor");
let (tx, rx) = oneshot::channel();
let result = Arc::new(Mutex::new(None));
let result_clone = result.clone();
// Spawn a task
Executor::spawn(async move {
tx.send(84).expect("Failed to send value");
});
// Spawn a task that waits for the result
Executor::spawn(async move {
match rx.await {
Ok(val) => *result_clone.lock().unwrap() = Some(val),
Err(_) => panic!("Failed to receive value"),
}
});
// Poll a few times to ensure the task completes
for _ in 0..10 {
Executor::poll_local();
std::thread::sleep(Duration::from_millis(10));
if result.lock().unwrap().is_some() {
break;
}
}
assert_eq!(*result.lock().unwrap(), Some(84));
}
================================================
FILE: any_spawner/tests/futures_runtime.rs
================================================
#![cfg(feature = "futures-executor")]
use any_spawner::Executor;
// All tests in this file use the same executor.
#[test]
fn can_spawn_local_future() {
use std::rc::Rc;
let _ = Executor::init_futures_executor();
let rc = Rc::new(());
Executor::spawn_local(async {
_ = rc;
});
Executor::spawn(async {});
}
#[test]
fn can_make_local_progress() {
use std::sync::{
atomic::{AtomicUsize, Ordering},
Arc,
};
let _ = Executor::init_futures_executor();
let counter = Arc::new(AtomicUsize::new(0));
Executor::spawn_local({
let counter = Arc::clone(&counter);
async move {
assert_eq!(counter.fetch_add(1, Ordering::AcqRel), 0);
Executor::spawn_local(async {
// Should not crash
});
}
});
Executor::poll_local();
assert_eq!(counter.load(Ordering::Acquire), 1);
}
================================================
FILE: any_spawner/tests/glib.rs
================================================
#![cfg(feature = "glib")]
use any_spawner::Executor;
use glib::{MainContext, MainLoop};
use serial_test::serial;
use std::{
cell::Cell,
future::Future,
rc::Rc,
sync::{
atomic::{AtomicBool, Ordering},
Arc, Mutex,
},
time::Duration,
};
// Helper to run a future to completion on a dedicated glib MainContext.
// Returns true if the future completed within the timeout, false otherwise.
fn run_on_glib_context<F>(fut: F)
where
F: Future<Output = ()> + Send + 'static,
{
let _ = Executor::init_glib();
let context = MainContext::default();
let main_loop = MainLoop::new(Some(&context), false);
let main_loop_clone = main_loop.clone();
Executor::spawn(async move {
fut.await;
main_loop_clone.quit();
});
main_loop.run();
}
// Helper to run a local (!Send) future on the glib context.
fn run_local_on_glib_context<F>(fut: F)
where
F: Future<Output = ()> + 'static,
{
let _ = Executor::init_glib();
let context = MainContext::default();
let main_loop = MainLoop::new(Some(&context), false);
let main_loop_clone = main_loop.clone();
Executor::spawn_local(async move {
fut.await;
main_loop_clone.quit();
});
main_loop.run();
}
// This test must run after a test that successfully initializes glib,
// or within its own process.
#[test]
#[serial]
fn test_glib_spawn() {
let success_flag = Arc::new(AtomicBool::new(false));
let flag_clone = success_flag.clone();
run_on_glib_context(async move {
// Simulate async work
futures_lite::future::yield_now().await;
flag_clone.store(true, Ordering::SeqCst);
// We need to give the spawned task time to run.
// The run_on_glib_context handles the main loop.
// We just need to ensure spawn happened correctly.
// Let's wait a tiny bit within the driving future to ensure spawn gets processed.
glib::timeout_future(Duration::from_millis(10)).await;
});
assert!(
success_flag.load(Ordering::SeqCst),
"Spawned future did not complete successfully"
);
}
// Similar conditions as test_glib_spawn regarding initialization state.
#[test]
#[serial]
fn test_glib_spawn_local() {
let success_flag = Rc::new(Cell::new(false));
let flag_clone = success_flag.clone();
run_local_on_glib_context(async move {
// Use Rc to make the future !Send
let non_send_data = Rc::new(Cell::new(10));
let data = non_send_data.get();
assert_eq!(data, 10, "Rc data should be accessible");
non_send_data.set(20); // Modify non-Send data
// Simulate async work
futures_lite::future::yield_now().await;
assert_eq!(
non_send_data.get(),
20,
"Rc data should persist modification"
);
flag_clone.set(true);
// Wait a tiny bit
glib::timeout_future(Duration::from_millis(10)).await;
});
assert!(
success_flag.get(),
"Spawned local future did not complete successfully"
);
}
// Test Executor::tick with glib backend
#[test]
#[serial]
fn test_glib_tick() {
run_on_glib_context(async {
let value = Arc::new(Mutex::new(false));
let value_clone = value.clone();
// Spawn a task that sets the value after a tick
Executor::spawn(async move {
Executor::tick().await;
*value_clone.lock().unwrap() = true;
});
// Allow some time for the task to complete
glib::timeout_future(Duration::from_millis(10)).await;
// Check that the value was set
assert!(*value.lock().unwrap());
});
}
// Test Executor::poll_local with glib backend (should be a no-op)
#[test]
#[serial]
fn test_glib_poll_local_is_no_op() {
// Ensure glib executor is initialized
let _ = Executor::init_glib();
// poll_local for glib is configured as a no-op
// Calling it should not panic or cause issues.
Executor::poll_local();
Executor::poll_local();
println!("Executor::poll_local called successfully (expected no-op).");
}
================================================
FILE: any_spawner/tests/local_custom_executor.rs
================================================
use any_spawner::Executor;
use std::sync::{
atomic::{AtomicBool, Ordering},
Arc,
};
#[test]
fn test_local_custom_executor() {
// Define a thread-local custom executor
struct LocalTestExecutor {
spawn_called: Arc<AtomicBool>,
spawn_local_called: Arc<AtomicBool>,
}
impl any_spawner::CustomExecutor for LocalTestExecutor {
fn spawn(&self, fut: any_spawner::PinnedFuture<()>) {
self.spawn_called.store(true, Ordering::SeqCst);
futures::executor::block_on(fut);
}
fn spawn_local(&self, fut: any_spawner::PinnedLocalFuture<()>) {
self.spawn_local_called.store(true, Ordering::SeqCst);
futures::executor::block_on(fut);
}
fn poll_local(&self) {
// No-op for this test
}
}
let local_spawn_called = Arc::new(AtomicBool::new(false));
let local_spawn_local_called = Arc::new(AtomicBool::new(false));
let local_executor = LocalTestExecutor {
spawn_called: local_spawn_called.clone(),
spawn_local_called: local_spawn_local_called.clone(),
};
// Initialize a thread-local executor
Executor::init_local_custom_executor(local_executor)
.expect("Failed to initialize local custom executor");
// Test spawn - should use the thread-local executor
Executor::spawn(async {
// Simple task
});
assert!(local_spawn_called.load(Ordering::SeqCst));
// Test spawn_local - should use the thread-local executor
Executor::spawn_local(async {
// Simple local task
});
assert!(local_spawn_local_called.load(Ordering::SeqCst));
}
================================================
FILE: any_spawner/tests/multiple_tasks.rs
================================================
#![cfg(feature = "tokio")]
use any_spawner::Executor;
use futures::channel::oneshot;
use std::sync::{Arc, Mutex};
#[tokio::test]
async fn test_multiple_tasks() {
Executor::init_tokio().expect("Failed to initialize tokio executor");
let counter = Arc::new(Mutex::new(0));
let tasks = 10;
let mut handles = Vec::new();
// Spawn multiple tasks that increment the counter
for _ in 0..tasks {
let counter_clone = counter.clone();
let (tx, rx) = oneshot::channel();
Executor::spawn(async move {
*counter_clone.lock().unwrap() += 1;
tx.send(()).expect("Failed to send completion signal");
});
handles.push(rx);
}
// Wait for all tasks to complete
for handle in handles {
handle.await.expect("Task failed");
}
// Verify that all tasks incremented the counter
assert_eq!(*counter.lock().unwrap(), tasks);
}
================================================
FILE: any_spawner/tests/tokio_executor.rs
================================================
#![cfg(feature = "tokio")]
use any_spawner::Executor;
use futures::channel::oneshot;
#[tokio::test]
async fn test_tokio_executor() {
// Initialize the tokio executor
Executor::init_tokio().expect("Failed to initialize tokio executor");
let (tx, rx) = oneshot::channel();
// Spawn a task that sends a value
Executor::spawn(async move {
tx.send(42).expect("Failed to send value");
});
// Wait for the spawned task to complete
assert_eq!(rx.await.unwrap(), 42);
}
================================================
FILE: any_spawner/tests/wasm_bindgen_tests.rs
================================================
#![cfg(all(feature = "wasm-bindgen", target_family = "wasm"))]
use any_spawner::Executor;
use futures::channel::oneshot;
use std::sync::{
atomic::{AtomicBool, Ordering},
Arc,
};
use wasm_bindgen_test::*;
wasm_bindgen_test_configure!(run_in_browser);
#[wasm_bindgen_test]
async fn test_wasm_bindgen_spawn_local() {
// Initialize the wasm-bindgen executor
let _ = Executor::init_wasm_bindgen();
// Create a channel to verify the task completes
let (tx, rx) = oneshot::channel();
// Spawn a local task (wasm doesn't support sending futures between threads)
Executor::spawn_local(async move {
// Simulate some async work
Executor::tick().await;
tx.send(42).expect("Failed to send result");
});
// Wait for the task to complete
let result = rx.await.expect("Failed to receive result");
assert_eq!(result, 42);
}
#[wasm_bindgen_test]
async fn test_wasm_bindgen_tick() {
// Initialize the wasm-bindgen executor if not already initialized
let _ = Executor::init_wasm_bindgen();
let flag = Arc::new(AtomicBool::new(false));
let flag_clone = flag.clone();
// Spawn a task that will set the flag
Executor::spawn_local(async move {
flag_clone.store(true, Ordering::SeqCst);
});
// Wait for a tick, which should allow the spawned task to run
Executor::tick().await;
// Verify the flag was set
assert!(flag.load(Ordering::SeqCst));
}
#[wasm_bindgen_test]
async fn test_multiple_wasm_bindgen_tasks() {
// Initialize once for all tests
let _ = Executor::init_wasm_bindgen();
// Create channels for multiple tasks
let (tx1, rx1) = oneshot::channel();
let (tx2, rx2) = oneshot::channel();
// Spawn multiple tasks
Executor::spawn_local(async move {
tx1.send("task1").expect("Failed to send from task1");
});
Executor::spawn_local(async move {
tx2.send("task2").expect("Failed to send from task2");
});
// Wait for both tasks to complete
let (result1, result2) = futures::join!(rx1, rx2);
assert_eq!(result1.unwrap(), "task1");
assert_eq!(result2.unwrap(), "task2");
}
// This test verifies that spawn (not local) fails on wasm as expected
#[wasm_bindgen_test]
#[should_panic]
fn test_wasm_bindgen_spawn_errors() {
let _ = Executor::init_wasm_bindgen();
// Using should_panic to test that Executor::spawn panics in wasm
Executor::spawn(async {
// This should panic since wasm-bindgen doesn't support Send futures
});
}
================================================
FILE: benchmarks/Cargo.toml
================================================
[package]
name = "benchmarks"
version = "0.1.0"
edition = "2021"
[dependencies]
l0410 = { package = "leptos", version = "0.4.10", features = [
"nightly",
"ssr",
] }
leptos = { path = "../leptos", features = ["ssr", "nightly"] }
leptos_reactive = { path = "../leptos_reactive", features = ["ssr", "nightly"] }
tachydom = { git = "https://github.com/gbj/tachys", features = [
"nightly",
"leptos",
] }
tachy_maccy = { git = "https://github.com/gbj/tachys", features = ["nightly"] }
sycamore = { version = "0.8.0", features = ["ssr"] }
yew = { version = "0.20.0", features = ["ssr"] }
tokio-test = "0.4.0"
miniserde = "0.1.0"
gloo = "0.8.0"
uuid = { version = "1.0", features = ["serde", "v4", "wasm-bindgen"] }
wasm-bindgen = "0.2.100"
lazy_static = "1.0"
log = "0.4.0"
strum = "0.24.0"
strum_macros = "0.24.0"
serde = { version = "1.0", features = ["derive", "rc"] }
serde_json = "1.0"
tera = "1.0"
[dependencies.web-sys]
version = "0.3.0"
features = ["Window", "Document", "HtmlElement", "HtmlInputElement"]
================================================
FILE: benchmarks/src/lib.rs
================================================
#![feature(test)]
extern crate test;
mod reactive;
mod ssr;
mod todomvc;
================================================
FILE: benchmarks/src/reactive.rs
================================================
use std::{cell::Cell, rc::Rc};
use test::Bencher;
#[bench]
fn leptos_deep_creation(b: &mut Bencher) {
use leptos::*;
let runtime = create_runtime();
b.iter(|| {
let signal = create_rw_signal(0);
let mut memos = Vec::<Memo<usize>>::new();
for _ in 0..1000usize {
let prev = memos.last().copied();
if let Some(prev) = prev {
memos.push(create_memo(move |_| prev.get() + 1));
} else {
memos.push(create_memo(move |_| signal.get() + 1));
}
}
});
runtime.dispose();
}
#[bench]
fn leptos_deep_update(b: &mut Bencher) {
use leptos::*;
let runtime = create_runtime();
b.iter(|| {
let signal = create_rw_signal(0);
let mut memos = Vec::<Memo<usize>>::new();
for _ in 0..1000usize {
if let Some(prev) = memos.last().copied() {
memos.push(create_memo(move |_| prev.get() + 1));
} else {
memos.push(create_memo(move |_| signal.get() + 1));
}
}
signal.set(1);
assert_eq!(memos[999].get(), 1001);
});
runtime.dispose();
}
#[bench]
fn leptos_narrowing_down(b: &mut Bencher) {
use leptos::*;
let runtime = create_runtime();
b.iter(|| {
let sigs = (0..1000).map(|n| create_signal(n)).collect::<Vec<_>>();
let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
let memo =
create_memo(move |_| reads.iter().map(|r| r.get()).sum::<i32>());
assert_eq!(memo(), 499500);
});
runtime.dispose();
}
#[bench]
fn leptos_fanning_out(b: &mut Bencher) {
use leptos::*;
let runtime = create_runtime();
b.iter(|| {
let sig = create_rw_signal(0);
let memos = (0..1000)
.map(|_| create_memo(move |_| sig.get()))
.collect::<Vec<_>>();
assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 0);
sig.set(1);
assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 1000);
});
runtime.dispose();
}
#[bench]
fn leptos_narrowing_update(b: &mut Bencher) {
use leptos::*;
let runtime = create_runtime();
b.iter(|| {
let acc = Rc::new(Cell::new(0));
let sigs = (0..1000).map(|n| create_signal(n)).collect::<Vec<_>>();
let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
let memo =
create_memo(move |_| reads.iter().map(|r| r.get()).sum::<i32>());
assert_eq!(memo(), 499500);
create_isomorphic_effect({
let acc = Rc::clone(&acc);
move |_| {
acc.set(memo());
}
});
assert_eq!(acc.get(), 499500);
writes[1].update(|n| *n += 1);
writes[10].update(|n| *n += 1);
writes[100].update(|n| *n += 1);
assert_eq!(acc.get(), 499503);
assert_eq!(memo(), 499503);
});
runtime.dispose();
}
#[bench]
fn l0410_deep_creation(b: &mut Bencher) {
use l0410::*;
let runtime = create_runtime();
b.iter(|| {
create_scope(runtime, |cx| {
let signal = create_rw_signal(cx, 0);
let mut memos = Vec::<Memo<usize>>::new();
for _ in 0..1000usize {
if let Some(prev) = memos.last().copied() {
memos.push(create_memo(cx, move |_| prev.get() + 1));
} else {
memos.push(create_memo(cx, move |_| signal.get() + 1));
}
}
})
.dispose()
});
runtime.dispose();
}
#[bench]
fn l0410_deep_update(b: &mut Bencher) {
use l0410::*;
let runtime = create_runtime();
b.iter(|| {
create_scope(runtime, |cx| {
let signal = create_rw_signal(cx, 0);
let mut memos = Vec::<Memo<usize>>::new();
for _ in 0..1000usize {
if let Some(prev) = memos.last().copied() {
memos.push(create_memo(cx, move |_| prev.get() + 1));
} else {
memos.push(create_memo(cx, move |_| signal.get() + 1));
}
}
signal.set(1);
assert_eq!(memos[999].get(), 1001);
})
.dispose()
});
runtime.dispose();
}
#[bench]
fn l0410_narrowing_down(b: &mut Bencher) {
use l0410::*;
let runtime = create_runtime();
b.iter(|| {
create_scope(runtime, |cx| {
let acc = Rc::new(Cell::new(0));
let sigs =
(0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
let memo = create_memo(cx, move |_| {
reads.iter().map(|r| r.get()).sum::<i32>()
});
assert_eq!(memo(), 499500);
})
.dispose()
});
runtime.dispose();
}
#[bench]
fn l0410_fanning_out(b: &mut Bencher) {
use l0410::*;
let runtime = create_runtime();
b.iter(|| {
create_scope(runtime, |cx| {
let sig = create_rw_signal(cx, 0);
let memos = (0..1000)
.map(|_| create_memo(cx, move |_| sig.get()))
.collect::<Vec<_>>();
assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 0);
sig.set(1);
assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 1000);
})
.dispose()
});
runtime.dispose();
}
#[bench]
fn l0410_narrowing_update(b: &mut Bencher) {
use l0410::*;
let runtime = create_runtime();
b.iter(|| {
create_scope(runtime, |cx| {
let acc = Rc::new(Cell::new(0));
let sigs =
(0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
let memo = create_memo(cx, move |_| {
reads.iter().map(|r| r.get()).sum::<i32>()
});
assert_eq!(memo.get(), 499500);
create_isomorphic_effect(cx, {
let acc = Rc::clone(&acc);
move |_| {
acc.set(memo.get());
}
});
assert_eq!(acc.get(), 499500);
writes[1].update(|n| *n += 1);
writes[10].update(|n| *n += 1);
writes[100].update(|n| *n += 1);
assert_eq!(acc.get(), 499503);
assert_eq!(memo.get(), 499503);
})
.dispose()
});
runtime.dispose();
}
#[bench]
fn l0410_scope_creation_and_disposal(b: &mut Bencher) {
use l0410::*;
let runtime = create_runtime();
b.iter(|| {
let acc = Rc::new(Cell::new(0));
let disposers = (0..1000)
.map(|_| {
create_scope(runtime, {
let acc = Rc::clone(&acc);
move |cx| {
let (r, w) = create_signal(cx, 0);
create_isomorphic_effect(cx, {
move |_| {
acc.set(r.get());
}
});
w.update(|n| *n += 1);
}
})
})
.collect::<Vec<_>>();
for disposer in disposers {
disposer.dispose();
}
});
runtime.dispose();
}
#[bench]
fn sycamore_narrowing_down(b: &mut Bencher) {
use sycamore::reactive::{
create_effect, create_memo, create_scope, create_signal,
};
b.iter(|| {
let d = create_scope(|cx| {
let acc = Rc::new(Cell::new(0));
let sigs = Rc::new(
(0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>(),
);
let memo = create_memo(cx, {
let sigs = Rc::clone(&sigs);
move || sigs.iter().map(|r| *r.get()).sum::<i32>()
});
assert_eq!(*memo.get(), 499500);
});
unsafe { d.dispose() };
});
}
#[bench]
fn sycamore_fanning_out(b: &mut Bencher) {
use sycamore::reactive::{
create_effect, create_memo, create_scope, create_signal,
};
b.iter(|| {
let d = create_scope(|cx| {
let sig = create_signal(cx, 0);
let memos = (0..1000)
.map(|_| create_memo(cx, move || sig.get()))
.collect::<Vec<_>>();
assert_eq!(memos.iter().map(|m| *(*m.get())).sum::<i32>(), 0);
sig.set(1);
assert_eq!(memos.iter().map(|m| *(*m.get())).sum::<i32>(), 1000);
});
unsafe { d.dispose() };
});
}
#[bench]
fn sycamore_deep_creation(b: &mut Bencher) {
use sycamore::reactive::*;
b.iter(|| {
let d = create_scope(|cx| {
let signal = create_signal(cx, 0);
let mut memos = Vec::<&ReadSignal<usize>>::new();
for _ in 0..1000usize {
if let Some(prev) = memos.last().copied() {
memos.push(create_memo(cx, move || *prev.get() + 1));
} else {
memos.push(create_memo(cx, move || *signal.get() + 1));
}
}
});
unsafe { d.dispose() };
});
}
#[bench]
fn sycamore_deep_update(b: &mut Bencher) {
use sycamore::reactive::*;
b.iter(|| {
let d = create_scope(|cx| {
let signal = create_signal(cx, 0);
let mut memos = Vec::<&ReadSignal<usize>>::new();
for _ in 0..1000usize {
if let Some(prev) = memos.last().copied() {
memos.push(create_memo(cx, move || *prev.get() + 1));
} else {
memos.push(create_memo(cx, move || *signal.get() + 1));
}
}
signal.set(1);
assert_eq!(*memos[999].get(), 1001);
});
unsafe { d.dispose() };
});
}
#[bench]
fn sycamore_narrowing_update(b: &mut Bencher) {
use sycamore::reactive::{
create_effect, create_memo, create_scope, create_signal,
};
b.iter(|| {
let d = create_scope(|cx| {
let acc = Rc::new(Cell::new(0));
let sigs = Rc::new(
(0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>(),
);
let memo = create_memo(cx, {
let sigs = Rc::clone(&sigs);
move || sigs.iter().map(|r| *r.get()).sum::<i32>()
});
assert_eq!(*memo.get(), 499500);
create_effect(cx, {
let acc = Rc::clone(&acc);
move || {
acc.set(*memo.get());
}
});
assert_eq!(acc.get(), 499500);
sigs[1].set(*sigs[1].get() + 1);
sigs[10].set(*sigs[10].get() + 1);
sigs[100].set(*sigs[100].get() + 1);
assert_eq!(acc.get(), 499503);
assert_eq!(*memo.get(), 499503);
});
unsafe { d.dispose() };
});
}
#[bench]
fn sycamore_scope_creation_and_disposal(b: &mut Bencher) {
use sycamore::reactive::{create_effect, create_scope, create_signal};
b.iter(|| {
let acc = Rc::new(Cell::new(0));
let disposers = (0..1000)
.map(|_| {
create_scope({
let acc = Rc::clone(&acc);
move |cx| {
let s = create_signal(cx, 0);
create_effect(cx, {
move || {
acc.set(*s.get());
}
});
s.set(*s.get() + 1);
}
})
})
.collect::<Vec<_>>();
for disposer in disposers {
unsafe {
disposer.dispose();
}
}
});
}
================================================
FILE: benchmarks/src/ssr.rs
================================================
use test::Bencher;
#[bench]
fn leptos_ssr_bench(b: &mut Bencher) {
use leptos::*;
let r = create_runtime();
b.iter(|| {
leptos::leptos_dom::HydrationCtx::reset_id();
#[component]
fn Counter(initial: i32) -> impl IntoView {
let (value, set_value) = create_signal(initial);
view! {
<div>
<button on:click=move |_| set_value.update(|value| *value -= 1)>"-1"</button>
<span>"Value: " {move || value().to_string()} "!"</span>
<button on:click=move |_| set_value.update(|value| *value += 1)>"+1"</button>
</div>
}
}
let rendered = view! {
<main>
<h1>"Welcome to our benchmark page."</h1>
<p>"Here's some introductory text."</p>
<Counter initial=1/>
<Counter initial=2/>
<Counter initial=3/>
</main>
}.into_view().render_to_string();
assert_eq!(
rendered,
"<main data-hk=\"0-0-0-1\"><h1 data-hk=\"0-0-0-2\">Welcome to our benchmark page.</h1><p data-hk=\"0-0-0-3\">Here's some introductory text.</p><div data-hk=\"0-0-0-5\"><button data-hk=\"0-0-0-6\">-1</button><span data-hk=\"0-0-0-7\">Value: <!>1<!--hk=0-0-0-8-->!</span><button data-hk=\"0-0-0-9\">+1</button></div><!--hk=0-0-0-4--><div data-hk=\"0-0-0-11\"><button data-hk=\"0-0-0-12\">-1</button><span data-hk=\"0-0-0-13\">Value: <!>2<!--hk=0-0-0-14-->!</span><button data-hk=\"0-0-0-15\">+1</button></div><!--hk=0-0-0-10--><div data-hk=\"0-0-0-17\"><button data-hk=\"0-0-0-18\">-1</button><span data-hk=\"0-0-0-19\">Value: <!>3<!--hk=0-0-0-20-->!</span><button data-hk=\"0-0-0-21\">+1</button></div><!--hk=0-0-0-16--></main>" );
});
r.dispose();
}
#[bench]
fn tachys_ssr_bench(b: &mut Bencher) {
use leptos::{create_runtime, create_signal, SignalGet, SignalUpdate};
use tachy_maccy::view;
use tachydom::view::{Render, RenderHtml};
use tachydom::html::element::ElementChild;
use tachydom::html::attribute::global::ClassAttribute;
use tachydom::html::attribute::global::GlobalAttributes;
use tachydom::html::attribute::global::OnAttribute;
use tachydom::renderer::dom::Dom;
let rt = create_runtime();
b.iter(|| {
fn counter(initial: i32) -> impl Render<Dom> + RenderHtml<Dom> {
let (value, set_value) = create_signal(initial);
view! {
<div>
<button on:click=move |_| set_value.update(|value| *value -= 1)>"-1"</button>
<span>"Value: " {move || value().to_string()} "!"</span>
<button on:click=move |_| set_value.update(|value| *value += 1)>"+1"</button>
</div>
}
}
let rendered = view! {
<main>
<h1>"Welcome to our benchmark page."</h1>
<p>"Here's some introductory text."</p>
{counter(1)}
{counter(2)}
{counter(3)}
</main>
}.to_html();
assert_eq!(
rendered,
"<main><h1>Welcome to our benchmark page.</h1><p>Here's some introductory text.</p><div><button>-1</button><span>Value: <!>1<!>!</span><button>+1</button></div><div><button>-1</button><span>Value: <!>2<!>!</span><button>+1</button></div><div><button>-1</button><span>Value: <!>3<!>!</span><button>+1</button></div></main>"
);
});
rt.dispose();
}
#[bench]
fn tera_ssr_bench(b: &mut Bencher) {
use serde::{Deserialize, Serialize};
use tera::*;
static TEMPLATE: &str = r#"<main>
<h1>Welcome to our benchmark page.</h1>
<p>Here's some introductory text.</p>
{% for counter in counters %}
<div>
<button>-1</button>
<span>Value: {{ counter.value }}!</span>
<button>+1</button>
</div>
{% endfor %}
</main>"#;
static LazyCell<TERA>: Tera = LazyLock::new(|| {
let mut tera = Tera::default();
tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
tera
});
#[derive(Serialize, Deserialize)]
struct Counter {
value: i32,
}
b.iter(|| {
let mut ctx = Context::new();
ctx.insert(
"counters",
&vec![
Counter { value: 0 },
Counter { value: 1 },
Counter { value: 2 },
],
);
let _ = TERA.render("template.html", &ctx).unwrap();
});
}
#[bench]
fn sycamore_ssr_bench(b: &mut Bencher) {
use sycamore::prelude::*;
use sycamore::*;
b.iter(|| {
_ = create_scope(|cx| {
#[derive(Prop)]
struct CounterProps {
initial: i32
}
#[component]
fn Counter<G: Html>(cx: Scope, props: CounterProps) -> View<G> {
let value = create_signal(cx, props.initial);
view! {
cx,
div {
button(on:click=|_| value.set(*value.get() - 1)) {
"-1"
}
span {
"Value: "
(value.get().to_string())
"!"
}
button(on:click=|_| value.set(*value.get() + 1)) {
"+1"
}
}
}
}
let rendered = render_to_string(|cx| view! {
cx,
main {
h1 {
"Welcome to our benchmark page."
}
p {
"Here's some introductory text."
}
Counter(initial = 1)
Counter(initial = 2)
Counter(initial = 3)
}
});
assert_eq!(
rendered,
"<main data-hk=\"0.0\"><h1 data-hk=\"0.1\">Welcome to our benchmark page.</h1><p data-hk=\"0.2\">Here's some introductory text.</p><!--#--><div data-hk=\"1.0\"><button data-hk=\"1.1\">-1</button><span data-hk=\"1.2\">Value: <!--#-->1<!--/-->!</span><button data-hk=\"1.3\">+1</button></div><!--/--><!----><!--#--><div data-hk=\"2.0\"><button data-hk=\"2.1\">-1</button><span data-hk=\"2.2\">Value: <!--#-->2<!--/-->!</span><button data-hk=\"2.3\">+1</button></div><!--/--><!----><!--#--><div data-hk=\"3.0\"><button data-hk=\"3.1\">-1</button><span data-hk=\"3.2\">Value: <!--#-->3<!--/-->!</span><button data-hk=\"3.3\">+1</button></div><!--/--></main>"
);
});
});
}
#[bench]
fn yew_ssr_bench(b: &mut Bencher) {
use yew::prelude::*;
use yew::ServerRenderer;
b.iter(|| {
#[derive(Properties, PartialEq, Eq, Debug)]
struct CounterProps {
initial: i32
}
#[function_component(Counter)]
fn counter(props: &CounterProps) -> Html {
let state = use_state(|| props.initial);
let incr_counter = {
let state = state.clone();
Callback::from(move |_| state.set(&*state + 1))
};
let decr_counter = {
let state = state.clone();
Callback::from(move |_| state.set(&*state - 1))
};
html! {
<div>
<h1>{"Welcome to our benchmark page."}</h1>
<p>{"Here's some introductory text."}</p>
<button onclick={decr_counter}> {"-1"} </button>
<p> {"Value: "} {*state} {"!"} </p>
<button onclick={incr_counter}> {"+1"} </button>
</div>
}
}
#[function_component]
fn App() -> Html {
html! {
<main>
<Counter initial=1/>
<Counter initial=2/>
<Counter initial=3/>
</main>
}
}
tokio_test::block_on(async {
let renderer = ServerRenderer::<App>::new();
let rendered = renderer.render().await;
assert_eq!(
rendered,
"<!--<[]>--><main><!--<[]>--><div><h1>Welcome to our benchmark page.</h1><p>Here's some introductory text.</p><button>-1</button><p>Value: 1!</p><button>+1</button></div><!--</[]>--><!--<[]>--><div><h1>Welcome to our benchmark page.</h1><p>Here's some introductory text.</p><button>-1</button><p>Value: 2!</p><button>+1</button></div><!--</[]>--><!--<[]>--><div><h1>Welcome to our benchmark page.</h1><p>Here's some introductory text.</p><button>-1</button><p>Value: 3!</p><button>+1</button></div><!--</[]>--></main><!--</[]>-->"
);
});
});
}
================================================
FILE: benchmarks/src/todomvc/leptos.rs
================================================
pub use leptos::*;
use miniserde::*;
use wasm_bindgen::JsCast;
use web_sys::HtmlInputElement;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Todos(pub Vec<Todo>);
const STORAGE_KEY: &str = "todos-leptos";
impl Todos {
pub fn new() -> Self {
Self(vec![])
}
pub fn new_with_1000() -> Self {
let todos = (0..1000)
.map(|id| Todo::new(id, format!("Todo #{id}")))
.collect();
Self(todos)
}
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
pub fn add(&mut self, todo: Todo) {
self.0.push(todo);
}
pub fn remove(&mut self, id: usize) {
self.0.retain(|todo| todo.id != id);
}
pub fn remaining(&self) -> usize {
self.0.iter().filter(|todo| !(todo.completed)()).count()
}
pub fn completed(&self) -> usize {
self.0.iter().filter(|todo| (todo.completed)()).count()
}
pub fn toggle_all(&self) {
// if all are complete, mark them all active instead
if self.remaining() == 0 {
for todo in &self.0 {
if todo.completed.get() {
(todo.set_completed)(false);
}
}
}
// otherwise, mark them all complete
else {
for todo in &self.0 {
(todo.set_completed)(true);
}
}
}
fn clear_completed(&mut self) {
self.0.retain(|todo| !todo.completed.get());
}
}
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Todo {
pub id: usize,
pub title: ReadSignal<String>,
pub set_title: WriteSignal<String>,
pub completed: ReadSignal<bool>,
pub set_completed: WriteSignal<bool>,
}
impl Todo {
pub fn new(id: usize, title: String) -> Self {
Self::new_with_completed(id, title, false)
}
pub fn new_with_completed(
id: usize,
title: String,
completed: bool,
) -> Self {
let (title, set_title) = create_signal(title);
let (completed, set_completed) = create_signal(completed);
Self {
id,
title,
set_title,
completed,
set_completed,
}
}
pub fn toggle(&self) {
self.set_completed
.update(|completed| *completed = !*completed);
}
}
const ESCAPE_KEY: u32 = 27;
const ENTER_KEY: u32 = 13;
#[component]
pub fn TodoMVC(todos: Todos) -> impl IntoView {
let mut next_id = todos
.0
.iter()
.map(|todo| todo.id)
.max()
.map(|last| last + 1)
.unwrap_or(0);
let (todos, set_todos) = create_signal(todos);
provide_context(set_todos);
let (mode, set_mode) = create_signal(Mode::All);
let add_todo = move |ev: web_sys::KeyboardEvent| {
let target = event_target::<HtmlInputElement>(&ev);
ev.stop_propagation();
let key_code = ev.unchecked_ref::<web_sys::KeyboardEvent>().key_code();
if key_code == ENTER_KEY {
let title = event_target_value(&ev);
let title = title.trim();
if !title.is_empty() {
let new = Todo::new(next_id, title.to_string());
set_todos.update(|t| t.add(new));
next_id += 1;
target.set_value("");
}
}
};
let filtered_todos = create_memo::<Vec<Todo>>(move |_| {
todos.with(|todos| match mode.get() {
Mode::All => todos.0.to_vec(),
Mode::Active => todos
.0
.iter()
.filter(|todo| !todo.completed.get())
.cloned()
.collect(),
Mode::Completed => todos
.0
.iter()
.filter(|todo| todo.completed.get())
.cloned()
.collect(),
})
});
// effect to serialize to JSON
// this does reactive reads, so it will automatically serialize on any relevant change
create_effect(move |_| {
if let Ok(Some(storage)) = window().local_storage() {
let objs = todos
.get()
.0
.iter()
.map(TodoSerialized::from)
.collect::<Vec<_>>();
let json = json::to_string(&objs);
if storage.set_item(STORAGE_KEY, &json).is_err() {
log::error!("error while trying to set item in localStorage");
}
}
});
view! {
<main>
<section class="todoapp">
<header class="header">
<h1>"todos"</h1>
<input
class="new-todo"
placeholder="What needs to be done?"
autofocus=""
on:keydown=add_todo
/>
</header>
<section class="main" class:hidden=move || todos.with(|t| t.is_empty())>
<input
id="toggle-all"
class="toggle-all"
type="checkbox"
prop:checked=move || todos.with(|t| t.remaining() > 0)
on:input=move |_| set_todos.update(|t| t.toggle_all())
/>
<label for="toggle-all">"Mark all as complete"</label>
<ul class="todo-list">
<For
each=filtered_todos
key=|todo| todo.id
children=move |todo: Todo| {
view! { <Todo todo=todo.clone()/> }
}
/>
</ul>
</section>
<footer class="footer" class:hidden=move || todos.with(|t| t.is_empty())>
<span class="todo-count">
<strong>{move || todos.with(|t| t.remaining().to_string())}</strong>
{move || if todos.with(|t| t.remaining()) == 1 { " item" } else { " items" }}
" left"
</span>
<ul class="filters">
<li>
<a
href="#/"
class="selected"
class:selected=move || mode() == Mode::All
>
"All"
</a>
</li>
<li>
<a href="#/active" class:selected=move || mode() == Mode::Active>
"Active"
</a>
</li>
<li>
<a href="#/completed" class:selected=move || mode() == Mode::Completed>
"Completed"
</a>
</li>
</ul>
<button
class="clear-completed hidden"
class:hidden=move || todos.with(|t| t.completed() == 0)
on:click=move |_| set_todos.update(|t| t.clear_completed())
>
"Clear completed"
</button>
</footer>
</section>
<footer class="info">
<p>"Double-click to edit a todo"</p>
<p>"Created by " <a href="http://todomvc.com">"Greg Johnston"</a></p>
<p>"Part of " <a href="http://todomvc.com">"TodoMVC"</a></p>
</footer>
</main>
}.into_view()
}
#[component]
pub fn Todo(todo: Todo) -> impl IntoView {
let (editing, set_editing) = create_signal(false);
let set_todos = use_context::<WriteSignal<Todos>>().unwrap();
//let input = NodeRef::new();
let save = move |value: &str| {
let value = value.trim();
if value.is_empty() {
set_todos.update(|t| t.remove(todo.id));
} else {
(todo.set_title)(value.to_string());
}
set_editing(false);
};
view! {
<li class="todo" class:editing=editing class:completed=move || (todo.completed)()>
<div class="view">
<input class="toggle" type="checkbox" prop:checked=move || (todo.completed)()/>
<label on:dblclick=move |_| set_editing(true)>{move || todo.title.get()}</label>
<button
class="destroy"
on:click=move |_| set_todos.update(|t| t.remove(todo.id))
></button>
</div>
{move || {
editing()
.then(|| {
view! {
<input
class="edit"
class:hidden=move || !(editing)()
prop:value=move || todo.title.get()
on:focusout=move |ev| save(&event_target_value(&ev))
on:keyup=move |ev| {
let key_code = ev.unchecked_ref::<web_sys::KeyboardEvent>().key_code();
if key_code == ENTER_KEY {
save(&event_target_value(&ev));
} else if key_code == ESCAPE_KEY {
set_editing(false);
}
}
/>
}
})
}}
</li>
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Mode {
Active,
Completed,
All,
}
impl Default for Mode {
fn default() -> Self {
Mode::All
}
}
pub fn route(hash: &str) -> Mode {
match hash {
"/active" => Mode::Active,
"/completed" => Mode::Completed,
_ => Mode::All,
}
}
#[derive(Serialize, Deserialize)]
pub struct TodoSerialized {
pub id: usize,
pub title: String,
pub completed: bool,
}
impl TodoSerialized {
pub fn into_todo(self, ) -> Todo {
Todo::new_with_completed(self.id, self.title, self.completed)
}
}
impl From<&Todo> for TodoSerialized {
fn from(todo: &Todo) -> Self {
Self {
id: todo.id,
title: todo.title.get(),
completed: (todo.completed)(),
}
}
}
================================================
FILE: benchmarks/src/todomvc/mod.rs
================================================
use test::Bencher;
mod leptos;
mod sycamore;
mod tachys;
mod tera;
mod yew;
#[bench]
fn leptos_todomvc_ssr(b: &mut Bencher) {
use ::leptos::*;
let runtime = create_runtime();
b.iter(|| {
use crate::todomvc::leptos::*;
let html = ::leptos::ssr::render_to_string(|| {
view! { <TodoMVC todos=Todos::new()/> }
});
assert!(html.len() > 1);
});
runtime.dispose();
}
#[bench]
fn tachys_todomvc_ssr(b: &mut Bencher) {
use ::leptos::*;
let runtime = create_runtime();
b.iter(|| {
use crate::todomvc::tachys::*;
use tachydom::view::{Render, RenderHtml};
let rendered = TodoMVC(Todos::new()).to_html();
assert_eq!(
rendered,
"<main><section class=\"todoapp\"><header class=\"header\"><h1>todos</h1><input placeholder=\"What needs to be done?\" autofocus class=\"new-todo\"></header><section class=\"main hidden\"><input id=\"toggle-all\" type=\"checkbox\" class=\"toggle-all\"><label for=\"toggle-all\">Mark all as complete</label><ul class=\"todo-list\"></ul></section><footer class=\"footer hidden\"><span class=\"todo-count\"><strong>0</strong><!> items<!> left</span><ul class=\"filters\"><li><a href=\"#/\" class=\"selected selected\">All</a></li><li><a href=\"#/active\" class=\"\">Active</a></li><li><a href=\"#/completed\" class=\"\">Completed</a></li></ul><button class=\"clear-completed hidden hidden\">Clear completed</button></footer></section><footer class=\"info\"><p>Double-click to edit a todo</p><p>Created by <a href=\"http://todomvc.com\">Greg Johnston</a></p><p>Part of <a href=\"http://todomvc.com\">TodoMVC</a></p></footer></main>" );
});
runtime.dispose();
}
#[bench]
fn sycamore_todomvc_ssr(b: &mut Bencher) {
use self::sycamore::*;
use ::sycamore::{prelude::*, *};
b.iter(|| {
_ = create_scope(|cx| {
let rendered = render_to_string(|cx| {
view! {
cx,
App()
}
});
assert!(rendered.len() > 1);
});
});
}
#[bench]
fn yew_todomvc_ssr(b: &mut Bencher) {
use self::yew::*;
use ::yew::{prelude::*, ServerRenderer};
b.iter(|| {
tokio_test::block_on(async {
let renderer = ServerRenderer::<App>::new();
let rendered = renderer.render().await;
assert!(rendered.len() > 1);
});
});
}
#[bench]
fn leptos_todomvc_ssr_with_1000(b: &mut Bencher) {
b.iter(|| {
use self::leptos::*;
use ::leptos::*;
let html = ::leptos::ssr::render_to_string(|| {
view! {
<TodoMVC todos=Todos::new_with_1000()/>
}
});
assert!(html.len() > 1);
});
}
#[bench]
fn tachys_todomvc_ssr_with_1000(b: &mut Bencher) {
use ::leptos::*;
let runtime = create_runtime();
b.iter(|| {
use crate::todomvc::tachys::*;
use tachydom::view::{Render, RenderHtml};
let rendered = TodoMVC(Todos::new_with_1000()).to_html();
assert!(rendered.len() > 20_000)
});
runtime.dispose();
}
#[bench]
fn sycamore_todomvc_ssr_with_1000(b: &mut Bencher) {
use self::sycamore::*;
use ::sycamore::{prelude::*, *};
b.iter(|| {
_ = create_scope(|cx| {
let rendered = render_to_string(|cx| {
view! {
cx,
AppWith1000()
}
});
assert!(rendered.len() > 1);
});
});
}
#[bench]
fn yew_todomvc_ssr_with_1000(b: &mut Bencher) {
use self::yew::*;
use ::yew::{prelude::*, ServerRenderer};
b.iter(|| {
tokio_test::block_on(async {
let renderer = ServerRenderer::<AppWith1000>::new();
let rendered = renderer.render().await;
assert!(rendered.len() > 1);
});
});
}
#[bench]
fn tera_todomvc_ssr(b: &mut Bencher) {
use ::leptos::*;
let runtime = create_runtime();
b.iter(|| {
use crate::todomvc::leptos::*;
let html = ::leptos::ssr::render_to_string(|| {
view! { <TodoMVC todos=Todos::new()/> }
});
assert!(html.len() > 1);
});
runtime.dispose();
}
================================================
FILE: benchmarks/src/todomvc/sycamore.rs
================================================
use serde::{Deserialize, Serialize};
use sycamore::prelude::*;
use uuid::Uuid;
use wasm_bindgen::JsCast;
use web_sys::{Event, HtmlInputElement, KeyboardEvent};
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash)]
pub struct Todo {
title: String,
completed: bool,
id: usize,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Filter {
All,
Active,
Completed,
}
impl Default for Filter {
fn default() -> Self {
Self::All
}
}
impl Filter {
fn url(self) -> &'static str {
match self {
Filter::All => "#",
Filter::Active => "#/active",
Filter::Completed => "#/completed",
}
}
fn get_filter_from_hash() -> Self {
let hash = web_sys::window().unwrap().location().hash().unwrap();
match hash.as_str() {
"#/active" => Filter::Active,
"#/completed" => Filter::Completed,
_ => Filter::All,
}
}
}
#[derive(Debug, Default, Clone)]
pub struct AppState {
pub todos: RcSignal<Vec<RcSignal<Todo>>>,
pub filter: RcSignal<Filter>,
}
impl AppState {
fn add_todo(&self, title: String, id: usize) {
self.todos.modify().push(create_rc_signal(Todo {
title,
completed: false,
id,
}))
}
fn remove_todo(&self, id: usize) {
self.todos.modify().retain(|todo| todo.get().id != id);
}
fn todos_left(&self) -> usize {
self.todos.get().iter().fold(
0,
|acc, todo| if todo.get().completed { acc } else { acc + 1 },
)
}
fn toggle_complete_all(&self) {
if self.todos_left() == 0 {
// make all todos active
for todo in self.todos.get().iter() {
if todo.get().completed {
todo.set(Todo {
completed: false,
..todo.get().as_ref().clone()
})
}
}
} else {
// make all todos completed
for todo in self.todos.get().iter() {
if !todo.get().completed {
todo.set(Todo {
completed: true,
..todo.get().as_ref().clone()
})
}
}
}
}
fn clear_completed(&self) {
self.todos.modify().retain(|todo| !todo.get().completed);
}
}
const KEY: &str = "todos-sycamore";
#[component]
pub fn App<G: Html>(cx: Scope) -> View<G> {
// Initialize application state
let todos = create_rc_signal(Vec::new());
let app_state = AppState {
todos,
filter: create_rc_signal(Filter::All),
};
provide_context(cx, app_state);
view! { cx,
div(class="todomvc-wrapper") {
section(class="todoapp") {
Header {}
List {}
Footer {}
}
Copyright {}
}
}
}
#[component]
pub fn AppWith1000<G: Html>(cx: Scope) -> View<G> {
// Initialize application state
let todos = (0..1000)
.map(|id| {
create_rc_signal(Todo {
title: format!("Todo #{id}"),
completed: false,
id,
})
})
.collect();
let todos = create_rc_signal(todos);
let app_state = AppState {
todos,
filter: create_rc_signal(Filter::All),
};
provide_context(cx, app_state);
view! { cx,
div(class="todomvc-wrapper") {
section(class="todoapp") {
Header {}
List {}
Footer {}
}
Copyright {}
}
}
}
#[component]
pub fn Copyright<G: Html>(cx: Scope) -> View<G> {
view! { cx,
footer(class="info") {
p { "Double click to edit a todo" }
p {
"Created by "
a(href="https://github.com/lukechu10", target="_blank") { "lukechu10" }
}
p {
"Part of "
a(href="http://todomvc.com") { "TodoMVC" }
}
}
}
}
#[component]
pub fn Header<G: Html>(cx: Scope) -> View<G> {
let app_state = use_context::<AppState>(cx);
let value = create_signal(cx, String::new());
let input_ref = create_node_ref(cx);
let handle_submit = |event: Event| {
let event: KeyboardEvent = event.unchecked_into();
if event.key() == "Enter" {
let mut task = value.get().as_ref().clone();
task = task.trim().to_string();
if !task.is_empty() {
app_state.add_todo(task, 0);
value.set("".to_string());
input_ref
.get::<DomNode>()
.unchecked_into::<HtmlInputElement>()
.set_value("");
}
}
};
view! { cx,
header(class="header") {
h1 { "todos" }
input(ref=input_ref,
class="new-todo",
placeholder="What needs to be done?",
bind:value=value,
on:keyup=handle_submit,
)
}
}
}
#[component(inline_props)]
pub fn Item<G: Html>(cx: Scope, todo: RcSignal<Todo>) -> View<G> {
let app_state = use_context::<AppState>(cx);
// Make `todo` live as long as the scope.
let todo = create_ref(cx, todo);
let title = || todo.get().title.clone();
let completed = create_selector(cx, || todo.get().completed);
let id = todo.get().id;
let editing = create_signal(cx, false);
let input_ref = create_node_ref(cx);
let value = create_signal(cx, "".to_string());
let handle_input = |event: Event| {
let target: HtmlInputElement = event.target().unwrap().unchecked_into();
value.set(target.value());
};
let toggle_completed = |_| {
todo.set(Todo {
completed: !todo.get().completed,
..todo.get().as_ref().clone()
});
};
let handle_dblclick = move |_| {
editing.set(true);
input_ref
.get::<DomNode>()
.unchecked_into::<HtmlInputElement>()
.focus()
.unwrap();
value.set(title());
};
let handle_blur = move || {
editing.set(false);
let mut value = value.get().as_ref().clone();
value = value.trim().to_string();
if value.is_empty() {
app_state.remove_todo(id);
} else {
todo.set(Todo {
title: value,
..todo.get().as_ref().clone()
})
}
};
let handle_submit = move |event: Event| {
let event: KeyboardEvent = event.unchecked_into();
match event.key().as_str() {
"Enter" => handle_blur(),
"Escape" => {
input_ref
.get::<DomNode>()
.unchecked_into::<HtmlInputElement>()
.set_value(&title());
editing.set(false);
}
_ => {}
}
};
let handle_destroy = move |_| {
app_state.remove_todo(id);
};
// We need a separate signal for checked because clicking the checkbox will detach the binding
// between the attribute and the view.
let checked = create_signal(cx, false);
create_effect(cx, || {
// Calling checked.set will also update the `checked` property on the input element.
checked.set(*completed.get())
});
let class = || {
format!(
"{} {}",
if *completed.get() { "completed" } else { "" },
if *editing.get() { "editing" } else { "" }
)
};
view! { cx,
li(class=class()) {
div(class="view") {
input(
class="toggle",
type="checkbox",
on:input=toggle_completed,
bind:checked=checked
)
label(on:dblclick=handle_dblclick) {
(title())
}
button(class="destroy", on:click=handle_destroy)
}
(if *editing.get() {
view! { cx,
input(ref=input_ref,
class="edit",
prop:value=&todo.get().title,
on:blur=move |_| handle_blur(),
on:keyup=handle_submit,
on:input=handle_input,
)
}
} else {
View::empty()
})
}
}
}
#[component]
pub fn List<G: Html>(cx: Scope) -> View<G> {
let app_state = use_context::<AppState>(cx);
let todos_left = create_selector(cx, || app_state.todos_left());
let filtered_todos = create_memo(cx, || {
app_state
.todos
.get()
.iter()
.filter(|todo| match *app_state.filter.get() {
Filter::All => true,
Filter::Active => !todo.get().completed,
Filter::Completed => todo.get().completed,
})
.cloned()
.collect::<Vec<_>>()
});
// We need a separate signal for checked because clicking the checkbox will detach the binding
// between the attribute and the view.
let checked = create_signal(cx, false);
create_effect(cx, || {
// Calling checked.set will also update the `checked` property on the input element.
checked.set(*todos_left.get() == 0)
});
view! { cx,
section(class="main") {
input(
id="toggle-all",
class="toggle-all",
type="checkbox",
readonly=true,
bind:checked=checked,
on:input=|_| app_state.toggle_complete_all()
)
label(for="toggle-all")
ul(class="todo-list") {
Keyed(
iterable=filtered_todos,
view=|cx, todo| view! { cx,
Item(todo=todo)
},
key=|todo| todo.get().id,
)
}
}
}
}
#[component(inline_props)]
pub fn TodoFilter<G: Html>(cx: Scope, filter: Filter) -> View<G> {
let app_state = use_context::<AppState>(cx);
let selected = move || filter == *app_state.filter.get();
let set_filter = |filter| app_state.filter.set(filter);
view! { cx,
li {
a(
class=if selected() { "selected" } else { "" },
href=filter.url(),
on:click=move |_| set_filter(filter),
) {
(format!("{filter:?}"))
}
}
}
}
#[component]
pub fn Footer<G: Html>(cx: Scope) -> View<G> {
let app_state = use_context::<AppState>(cx);
let items_text = || match app_state.todos_left() {
1 => "item",
_ => "items",
};
let has_completed_todos =
create_selector(cx, || app_state.todos_left() < app_state.todos.get().len());
let handle_clear_completed = |_| app_state.clear_completed();
view! { cx,
footer(class="footer") {
span(class="todo-count") {
strong { (app_state.todos_left()) }
span { " " (items_text()) " left" }
}
ul(class="filters") {
TodoFilter(filter=Filter::All)
TodoFilter(filter=Filter::Active)
TodoFilter(filter=Filter::Completed)
}
(if *has_completed_todos.get() {
view! { cx,
button(class="clear-completed", on:click=handle_clear_completed) {
"Clear completed"
}
}
} else {
view! { cx, }
})
}
}
}
================================================
FILE: benchmarks/src/todomvc/tachys.rs
================================================
pub use leptos_reactive::*;
use miniserde::*;
use tachy_maccy::view;
use tachydom::{
html::{
attribute::global::{ClassAttribute, GlobalAttributes, OnAttribute},
element::ElementChild,
},
renderer::dom::Dom,
view::{keyed::keyed, Render, RenderHtml},
};
use wasm_bindgen::JsCast;
use web_sys::HtmlInputElement;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Todos(pub Vec<Todo>);
const STORAGE_KEY: &str = "todos-leptos";
impl Todos {
pub fn new() -> Self {
Self(vec![])
}
pub fn new_with_1000() -> Self {
let todos = (0..1000)
.map(|id| Todo::new(id, format!("Todo #{id}")))
.collect();
Self(todos)
}
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
pub fn add(&mut self, todo: Todo) {
self.0.push(todo);
}
pub fn remove(&mut self, id: usize) {
self.0.retain(|todo| todo.id != id);
}
pub fn remaining(&self) -> usize {
self.0.iter().filter(|todo| !(todo.completed)()).count()
}
pub fn completed(&self) -> usize {
self.0.iter().filter(|todo| (todo.completed)()).count()
}
pub fn toggle_all(&self) {
// if all are complete, mark them all active instead
if self.remaining() == 0 {
for todo in &self.0 {
if todo.completed.get() {
(todo.set_completed)(false);
}
}
}
// otherwise, mark them all complete
else {
for todo in &self.0 {
(todo.set_completed)(true);
}
}
}
fn clear_completed(&mut self) {
self.0.retain(|todo| !todo.completed.get());
}
}
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Todo {
pub id: usize,
pub title: ReadSignal<String>,
pub set_title: WriteSignal<String>,
pub completed: ReadSignal<bool>,
pub set_completed: WriteSignal<bool>,
}
impl Todo {
pub fn new(id: usize, title: String) -> Self {
Self::new_with_completed(id, title, false)
}
pub fn new_with_completed(
id: usize,
title: String,
completed: bool,
) -> Self {
let (title, set_title) = create_signal(title);
let (completed, set_completed) = create_signal(completed);
Self {
id,
title,
set_title,
completed,
set_completed,
}
}
pub fn toggle(&self) {
self.set_completed
.update(|completed| *completed = !*completed);
}
}
const ESCAPE_KEY: u32 = 27;
const ENTER_KEY: u32 = 13;
pub fn TodoMVC(todos: Todos) -> impl Render<Dom> + RenderHtml<Dom> {
let mut next_id = todos
.0
.iter()
.map(|todo| todo.id)
.max()
.map(|last| last + 1)
.unwrap_or(0);
let (todos, set_todos) = create_signal(todos);
provide_context(set_todos);
let (mode, set_mode) = create_signal(Mode::All);
let add_todo = move |ev: web_sys::KeyboardEvent| {
todo!()
/* let target = event_target::<HtmlInputElement>(&ev);
ev.stop_propagation();
let key_code = ev.unchecked_ref::<web_sys::KeyboardEvent>().key_code();
if key_code == ENTER_KEY {
let title = event_target_value(&ev);
let title = title.trim();
if !title.is_empty() {
let new = Todo::new(next_id, title.to_string());
set_todos.update(|t| t.add(new));
next_id += 1;
target.set_value("");
}
} */
};
let filtered_todos = create_memo::<Vec<Todo>>(move |_| {
todos.with(|todos| match mode.get() {
Mode::All => todos.0.to_vec(),
Mode::Active => todos
.0
.iter()
.filter(|todo| !todo.completed.get())
.cloned()
.collect(),
Mode::Completed => todos
.0
.iter()
.filter(|todo| todo.completed.get())
.cloned()
.collect(),
})
});
// effect to serialize to JSON
// this does reactive reads, so it will automatically serialize on any relevant change
create_effect(move |_| {
()
/* if let Ok(Some(storage)) = window().local_storage() {
let objs = todos
.get()
.0
.iter()
.map(TodoSerialized::from)
.collect::<Vec<_>>();
let json = json::to_string(&objs);
if storage.set_item(STORAGE_KEY, &json).is_err() {
log::error!("error while trying to set item in localStorage");
}
} */
});
view! {
<main>
<section class="todoapp">
<header class="header">
<h1>"todos"</h1>
<input
class="new-todo"
placeholder="What needs to be done?"
autofocus
/>
</header>
<section class="main" class:hidden=move || todos.with(|t| t.is_empty())>
<input
id="toggle-all"
class="toggle-all"
r#type="checkbox"
//prop:checked=move || todos.with(|t| t.remaining() > 0)
on:input=move |_| set_todos.update(|t| t.toggle_all())
/>
<label r#for="toggle-all">"Mark all as complete"</label>
<ul class="todo-list">
{move || {
keyed(filtered_todos.get(), |todo| todo.id, Todo)
}}
</ul>
</section>
<footer class="footer" class:hidden=move || todos.with(|t| t.is_empty())>
<span class="todo-count">
<strong>{move || todos.with(|t| t.remaining().to_string())}</strong>
{move || if todos.with(|t| t.remaining()) == 1 { " item" } else { " items" }}
" left"
</span>
<ul class="filters">
<li>
<a
href="#/"
class="selected"
class:selected=move || mode() == Mode::All
>
"All"
</a>
</li>
<li>
<a href="#/active" class:selected=move || mode() == Mode::Active>
"Active"
</a>
</li>
<li>
<a href="#/completed" class:selected=move || mode() == Mode::Completed>
"Completed"
</a>
</li>
</ul>
<button
class="clear-completed hidden"
class:hidden=move || todos.with(|t| t.completed() == 0)
on:click=move |_| set_todos.update(|t| t.clear_completed())
>
"Clear completed"
</button>
</footer>
</section>
<footer class="info">
<p>"Double-click to edit a todo"</p>
<p>"Created by " <a href="http://todomvc.com">"Greg Johnston"</a></p>
<p>"Part of " <a href="http://todomvc.com">"TodoMVC"</a></p>
</footer>
</main>
}
}
pub fn Todo(todo: Todo) -> impl Render<Dom> + RenderHtml<Dom> {
let (editing, set_editing) = create_signal(false);
let set_todos = use_context::<WriteSignal<Todos>>().unwrap();
//let input = NodeRef::new();
let save = move |value: &str| {
let value = value.trim();
if value.is_empty() {
set_todos.update(|t| t.remove(todo.id));
} else {
(todo.set_title)(value.to_string());
}
set_editing(false);
};
view! {
<li class="todo" class:editing=editing class:completed=move || (todo.completed)()>
/* <div class="view">
<input class="toggle" r#type="checkbox"/>
<label on:dblclick=move |_| set_editing(true)>{move || todo.title.get()}</label>
<button
class="destroy"
on:click=move |_| set_todos.update(|t| t.remove(todo.id))
></button>
</div>
{move || {
editing()
.then(|| {
view! {
<input
class="edit"
class:hidden=move || !(editing)()
/>
}
})
}} */
</li>
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Mode {
Active,
Completed,
All,
}
impl Default for Mode {
fn default() -> Self {
Mode::All
}
}
pub fn route(hash: &str) -> Mode {
match hash {
"/active" => Mode::Active,
"/completed" => Mode::Completed,
_ => Mode::All,
}
}
#[derive(Serialize, Deserialize)]
pub struct TodoSerialized {
pub id: usize,
pub title: String,
pub completed: bool,
}
impl TodoSerialized {
pub fn into_todo(self) -> Todo {
Todo::new_with_completed(self.id, self.title, self.completed)
}
}
impl From<&Todo> for TodoSerialized {
fn from(todo: &Todo) -> Self {
Self {
id: todo.id,
title: todo.title.get(),
completed: (todo.completed)(),
}
}
}
================================================
FILE: benchmarks/src/todomvc/tera.rs
================================================
use test::Bencher;
static TEMPLATE: &str = r#"<main>
<section class="todoapp">
<header class="header">
<h1>"todos"</h1>
<input class="new-todo" placeholder="What needs to be done? />
</header>
<section class="main" class={{ main_class }}>
<input id="toggle-all" class="toggle-all" type="checkbox"
checked={{ toggle_checked }}
/>
<label for="toggle-all">"Mark all as complete"</label>
<ul class="todo-list">
{% for todo in todos %}
<li
class={{ todo.class }}
>
<div class="view">
<input
class="toggle"
type="checkbox"
checked={{ todo.completed }}
/>
<label>
{{ todo.label }}
</label>
<button class="destroy"/>
</div>
{% if todo.editing %}
<input
class="edit"
value={{ todo.label }}
/>
{% endif %}
</li>
{% endfor %}
</ul>
</section>
{% if todos_empty %}
{% else %}
<footer class="footer">
<span class="todo-count">
<strong>{{ todos_remaining }}</strong>
{% if todos_remaining == 1 %}
item
{% else %}
items
{% endif %}
left
</span>
<ul class="filters">
{% if mode_all %}
<li><a href="/" class="selected">All</a></li>
{% else %}
<li><a href="/">All</a></li>
{% endif %}
{% if mode_active %}
<li><a href="/active" class="selected">Active</a></li>
{% else %}
<li><a href="/active">Active</a></li>
{% endif %}
{% if mode_completed %}
<li><a href="/completed" class="selected">Completed</a></li>
{% else %}
<li><a href="/completed">Completed</a></li>
{% endif %}
</ul>
{% if todos_completed > 0 %}
<button
class="clear-completed hidden"
>
Clear completed
</button>
{% endif %}
</footer>
{% endif %}
</section>
<footer class="info">
<p>"Double-click to edit a todo"</p>
<p>"Created by "<a href="http://todomvc.com">"Greg Johnston"</a></p>
<p>"Part of "<a href="http://todomvc.com">"TodoMVC"</a></p>
</footer>
</main>"#;
#[bench]
fn tera_todomvc_ssr(b: &mut Bencher) {
use serde::{Deserialize, Serialize};
use tera::*;
static LazyLock<TERA>: Tera = LazyLock( || {
let mut tera = Tera::default();
tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
tera
});
#[derive(Serialize, Deserialize)]
struct Todo {
label: String,
completed: bool,
editing: bool,
class: String,
}
b.iter(|| {
let mut ctx = Context::new();
let todos = Vec::<Todo>::new();
let remaining = todos.iter().filter(|todo| !todo.completed).count();
let completed = todos.iter().filter(|todo| todo.completed).count();
ctx.insert("todos", &todos);
ctx.insert("main_class", &if todos.is_empty() { "hidden" } else { "" });
ctx.insert("toggle_checked", &(remaining > 0));
ctx.insert("todos_remaining", &remaining);
ctx.insert("todos_completed", &completed);
ctx.insert("todos_empty", &todos.is_empty());
ctx.insert("mode_all", &true);
ctx.insert("mode_active", &false);
ctx.insert("mode_selected", &false);
let _ = TERA.render("template.html", &ctx).unwrap();
});
}
#[bench]
fn tera_todomvc_ssr_1000(b: &mut Bencher) {
use serde::{Deserialize, Serialize};
use tera::*;
static TERA: LazyLock<Tera> = LazyLock::new(|| {
let mut tera = Tera::default();
tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
tera
});
#[derive(Serialize, Deserialize)]
struct Todo {
id: usize,
label: String,
completed: bool,
editing: bool,
class: String,
}
b.iter(|| {
let mut ctx = Context::new();
let todos = (0..1000)
.map(|id| Todo {
id,
label: format!("Todo #{id}"),
completed: false,
editing: false,
class: "todo".to_string(),
})
.collect::<Vec<_>>();
let remaining = todos.iter().filter(|todo| !todo.completed).count();
let completed = todos.iter().filter(|todo| todo.completed).count();
ctx.insert("todos", &todos);
ctx.insert("main_class", &if todos.is_empty() { "hidden" } else { "" });
ctx.insert("toggle_checked", &(remaining > 0));
ctx.insert("todos_remaining", &remaining);
ctx.insert("todos_completed", &completed);
ctx.insert("todos_empty", &todos.is_empty());
ctx.insert("mode_all", &true);
ctx.insert("mode_active", &false);
ctx.insert("mode_selected", &false);
let _ = TERA.render("template.html", &ctx).unwrap();
});
}
================================================
FILE: benchmarks/src/todomvc/yew.rs
================================================
use gloo::storage::{LocalStorage, Storage};
use strum::IntoEnumIterator;
use web_sys::HtmlInputElement as InputElement;
use yew::events::{FocusEvent, KeyboardEvent};
use yew::html::Scope;
use yew::{classes, html, Classes, Component, Context, Html, NodeRef, TargetCast};
const KEY: &str = "yew.todomvc.self";
pub enum Msg {
Add(String),
Edit((usize, String)),
Remove(usize),
SetFilter(Filter),
ToggleAll,
ToggleEdit(usize),
Toggle(usize),
ClearCompleted,
Focus,
}
pub struct App {
state: State,
focus_ref: NodeRef,
}
impl Component for App {
type Message = Msg;
type Properties = ();
fn create(_ctx: &Context<Self>) -> Self {
let entries = vec![]; //LocalStorage::get(KEY).unwrap_or_else(|_| Vec::new());
let state = State {
entries,
filter: Filter::All,
edit_value: "".into(),
};
let focus_ref = NodeRef::default();
Self { state, focus_ref }
}
fn update(&mut self, _ctx: &Context<Self>, msg: Self::Message) -> bool {
match msg {
Msg::Add(description) => {
if !description.is_empty() {
let entry = Entry {
description: description.trim().to_string(),
completed: false,
editing: false,
};
self.state.entries.push(entry);
}
}
Msg::Edit((idx, edit_value)) => {
self.state.complete_edit(idx, edit_value.trim().to_string());
self.state.edit_value = "".to_string();
}
Msg::Remove(idx) => {
self.state.remove(idx);
}
Msg::SetFilter(filter) => {
self.state.filter = filter;
}
Msg::ToggleEdit(idx) => {
let entry = self
.state
.entries
.iter()
.filter(|e| self.state.filter.fits(e))
.nth(idx)
.unwrap();
self.state.edit_value = entry.description.clone();
self.state.clear_all_edit();
self.state.toggle_edit(idx);
}
Msg::ToggleAll => {
let status = !self.state.is_all_completed();
self.state.toggle_all(status);
}
Msg::Toggle(idx) => {
self.state.toggle(idx);
}
Msg::ClearCompleted => {
self.state.clear_completed();
}
Msg::Focus => {
if let Some(input) = self.focus_ref.cast::<InputElement>() {
input.focus().unwrap();
}
}
}
LocalStorage::set(KEY, &self.state.entries).expect("failed to set");
true
}
fn view(&self, ctx: &Context<Self>) -> Html {
let hidden_class = if self.state.entries.is_empty() {
"hidden"
} else {
""
};
html! {
<div class="todomvc-wrapper">
<section class="todoapp">
<header class="header">
<h1>{ "todos" }</h1>
{ self.view_input(ctx.link()) }
</header>
<section class={classes!("main", hidden_class)}>
<input
type="checkbox"
class="toggle-all"
id="toggle-all"
checked={self.state.is_all_completed()}
onclick={ctx.link().callback(|_| Msg::ToggleAll)}
/>
<label for="toggle-all" />
<ul class="todo-list">
{ for self.state.entries.iter().filter(|e| self.state.filter.fits(e)).enumerate().map(|e| self.view_entry(e, ctx.link())) }
</ul>
</section>
<footer class={classes!("footer", hidden_class)}>
<span class="todo-count">
<strong>{ self.state.total() }</strong>
{ " item(s) left" }
</span>
<ul class="filters">
{ for Filter::iter().map(|flt| self.view_filter(flt, ctx.link())) }
</ul>
<button class="clear-completed" onclick={ctx.link().callback(|_| Msg::ClearCompleted)}>
{ format!("Clear completed ({})", self.state.total_completed()) }
</button>
</footer>
</section>
<footer class="info">
<p>{ "Double-click to edit a todo" }</p>
<p>{ "Written by " }<a href="https://github.com/DenisKolodin/" target="_blank">{ "Denis Kolodin" }</a></p>
<p>{ "Part of " }<a href="http://todomvc.com/" target="_blank">{ "TodoMVC" }</a></p>
</footer>
</div>
}
}
}
impl App {
fn view_filter(&self, filter: Filter, link: &Scope<Self>) -> Html {
let cls = if self.state.filter == filter {
"selected"
} else {
"not-selected"
};
html! {
<li>
<a class={cls}
href={filter.as_href()}
onclick={link.callback(move |_| Msg::SetFilter(filter))}
>
{ filter }
</a>
</li>
}
}
fn view_input(&self, link: &Scope<Self>) -> Html {
let onkeypress = link.batch_callback(|e: KeyboardEvent| {
if e.key() == "Enter" {
let input: InputElement = e.target_unchecked_into();
let value = input.value();
input.set_value("");
Some(Msg::Add(value))
} else {
None
}
});
html! {
// You can use standard Rust comments. One line:
// <li></li>
<input
class="new-todo"
placeholder="What needs to be done?"
{onkeypress}
/>
/* Or multiline:
<ul>
<li></li>
</ul>
*/
}
}
fn view_entry(&self, (idx, entry): (usize, &Entry), link: &Scope<Self>) -> Html {
let mut class = Classes::from("todo");
if entry.editing {
class.push(" editing");
}
if entry.completed {
class.push(" completed");
}
html! {
<li {class}>
<div class="view">
<input
type="checkbox"
class="toggle"
checked={entry.completed}
onclick={link.callback(move |_| Msg::Toggle(idx))}
/>
<label ondblclick={link.callback(move |_| Msg::ToggleEdit(idx))}>{ &entry.description }</label>
<button class="destroy" onclick={link.callback(move |_| Msg::Remove(idx))} />
</div>
{ self.view_entry_edit_input((idx, entry), link) }
</li>
}
}
fn view_entry_edit_input(&self, (idx, entry): (usize, &Entry), link: &Scope<Self>) -> Html {
let edit = move |input: InputElement| {
let value = input.value();
input.set_value("");
Msg::Edit((idx, value))
};
let onblur = link.callback(move |e: FocusEvent| edit(e.target_unchecked_into()));
let onkeypress = link.batch_callback(move |e: KeyboardEvent| {
(e.key() == "Enter").then(|| edit(e.target_unchecked_into()))
});
if entry.editing {
html! {
<input
class="edit"
type="text"
ref={self.focus_ref.clone()}
value={self.state.edit_value.clone()}
onmouseover={link.callback(|_| Msg::Focus)}
{onblur}
{onkeypress}
/>
}
} else {
html! { <input type="hidden" /> }
}
}
}
pub struct AppWith1000 {
state: State,
focus_ref: NodeRef,
}
impl Component for AppWith1000 {
type Message = Msg;
type Properties = ();
fn create(_ctx: &Context<Self>) -> Self {
let entries = (0..1000)
.map(|id| Entry {
description: format!("Todo #{id}"),
completed: false,
editing: false,
})
.collect();
let state = State {
entries,
filter: Filter::All,
edit_value: "".into(),
};
let focus_ref = NodeRef::default();
Self { state, focus_ref }
}
fn update(&mut self, _ctx: &Context<Self>, msg: Self::Message) -> bool {
match msg {
Msg::Add(description) => {
if !description.is_empty() {
let entry = Entry {
description: description.trim().to_string(),
completed: false,
editing: false,
};
self.state.entries.push(entry);
}
}
Msg::Edit((idx, edit_value)) => {
self.state.complete_edit(idx, edit_value.trim().to_string());
self.state.edit_value = "".to_string();
}
Msg::Remove(idx) => {
self.state.remove(idx);
}
Msg::SetFilter(filter) => {
self.state.filter = filter;
}
Msg::ToggleEdit(idx) => {
let entry = self
.state
.entries
.iter()
.filter(|e| self.state.filter.fits(e))
.nth(idx)
.unwrap();
self.state.edit_value = entry.description.clone();
self.state.clear_all_edit();
self.state.toggle_edit(idx);
}
Msg::ToggleAll => {
let status = !self.state.is_all_completed();
self.state.toggle_all(status);
}
Msg::Toggle(idx) => {
self.state.toggle(idx);
}
Msg::ClearCompleted => {
self.state.clear_completed();
}
Msg::Focus => {
if let Some(input) = self.focus_ref.cast::<InputElement>() {
input.focus().unwrap();
}
}
}
LocalStorage::set(KEY, &self.state.entries).expect("failed to set");
true
}
fn view(&self, ctx: &Context<Self>) -> Html {
let hidden_class = if self.state.entries.is_empty() {
"hidden"
} else {
""
};
html! {
<div class="todomvc-wrapper">
<section class="todoapp">
<header class="header">
<h1>{ "todos" }</h1>
{ self.view_input(ctx.link()) }
</header>
<section class={classes!("main", hidden_class)}>
<input
type="checkbox"
class="toggle-all"
id="toggle-all"
checked={self.state.is_all_completed()}
onclick={ctx.link().callback(|_| Msg::ToggleAll)}
/>
<label for="toggle-all" />
<ul class="todo-list">
{ for self.state.entries.iter().filter(|e| self.state.filter.fits(e)).enumerate().map(|e| self.view_entry(e, ctx.link())) }
</ul>
</section>
<footer class={classes!("footer", hidden_class)}>
<span class="todo-count">
<strong>{ self.state.total() }</strong>
{ " item(s) left" }
</span>
<ul class="filters">
{ for Filter::iter().map(|flt| self.view_filter(flt, ctx.link())) }
</ul>
<button class="clear-completed" onclick={ctx.link().callback(|_| Msg::ClearCompleted)}>
{ format!("Clear completed ({})", self.state.total_completed()) }
</button>
</footer>
</section>
<footer class="info">
<p>{ "Double-click to edit a todo" }</p>
<p>{ "Written by " }<a href="https://github.com/DenisKolodin/" target="_blank">{ "Denis Kolodin" }</a></p>
<p>{ "Part of " }<a href="http://todomvc.com/" target="_blank">{ "TodoMVC" }</a></p>
</footer>
</div>
}
}
}
impl AppWith1000 {
fn view_filter(&self, filter: Filter, link: &Scope<Self>) -> Html {
let cls = if self.state.filter == filter {
"selected"
} else {
"not-selected"
};
html! {
<li>
<a class={cls}
href={filter.as_href()}
onclick={link.callback(move |_| Msg::SetFilter(filter))}
>
{ filter }
</a>
</li>
}
}
fn view_input(&self, link: &Scope<Self>) -> Html {
let onkeypress = link.batch_callback(|e: KeyboardEvent| {
if e.key() == "Enter" {
let input: InputElement = e.target_unchecked_into();
let value = input.value();
input.set_value("");
Some(Msg::Add(value))
} else {
None
}
});
html! {
// You can use standard Rust comments. One line:
// <li></li>
<input
class="new-todo"
placeholder="What needs to be done?"
{onkeypress}
/>
/* Or multiline:
<ul>
<li></li>
</ul>
*/
}
}
fn view_entry(&self, (idx, entry): (usize, &Entry), link: &Scope<Self>) -> Html {
let mut class = Classes::from("todo");
if entry.editing {
class.push(" editing");
}
if entry.completed {
class.push(" completed");
}
html! {
<li {class}>
<div class="view">
<input
type="checkbox"
class="toggle"
checked={entry.completed}
onclick={link.callback(move |_| Msg::Toggle(idx))}
/>
<label ondblclick={link.callback(move |_| Msg::ToggleEdit(idx))}>{ &entry.description }</label>
<button class="destroy" onclick={link.callback(move |_| Msg::Remove(idx))} />
</div>
{ self.view_entry_edit_input((idx, entry), link) }
</li>
}
}
fn view_entry_edit_input(&self, (idx, entry): (usize, &Entry), link: &Scope<Self>) -> Html {
let edit = move |input: InputElement| {
let value = input.value();
input.set_value("");
Msg::Edit((idx, value))
};
let onblur = link.callback(move |e: FocusEvent| edit(e.target_unchecked_into()));
let onkeypress = link.batch_callback(move |e: KeyboardEvent| {
(e.key() == "Enter").then(|| edit(e.target_unchecked_into()))
});
if entry.editing {
html! {
<input
class="edit"
type="text"
ref={self.focus_ref.clone()}
value={self.state.edit_value.clone()}
onmouseover={link.callback(|_| Msg::Focus)}
{onblur}
{onkeypress}
/>
}
} else {
html! { <input type="hidden" /> }
}
}
}
use serde::{Deserialize, Serialize};
use strum_macros::{Display, EnumIter};
#[derive(Debug, Serialize, Deserialize)]
pub struct State {
pub entries: Vec<Entry>,
pub filter: Filter,
pub edit_value: String,
}
impl State {
pub fn total(&self) -> usize {
self.entries.len()
}
pub fn total_completed(&self) -> usize {
self.entries
.iter()
.filter(|e| Filter::Completed.fits(e))
.count()
}
pub fn is_all_completed(&self) -> bool {
let mut filtered_iter = self
.entries
.iter()
.filter(|e| self.filter.fits(e))
.peekable();
if filtered_iter.peek().is_none() {
retur
gitextract_0avvtdt6/
├── .config/
│ └── nextest.toml
├── .github/
│ ├── FUNDING.yml
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.md
│ │ ├── config.yml
│ │ └── feature_request.md
│ ├── dependabot.yml
│ └── workflows/
│ ├── autofix.yml
│ ├── ci.yml
│ ├── get-example-changed.yml
│ ├── get-examples-matrix.yml
│ ├── get-leptos-changed.yml
│ ├── get-leptos-matrix.yml
│ ├── publish-book.yml
│ └── run-cargo-make-task.yml
├── .gitignore
├── ARCHITECTURE.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── Cargo.toml
├── LICENSE
├── Makefile.toml
├── README.md
├── SECURITY.md
├── TODO.md
├── any_error/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── any_spawner/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ ├── src/
│ │ └── lib.rs
│ └── tests/
│ ├── already_set_error.rs
│ ├── async_executor.rs
│ ├── custom_executor.rs
│ ├── custom_runtime.rs
│ ├── executor_tick.rs
│ ├── futures_executor.rs
│ ├── futures_runtime.rs
│ ├── glib.rs
│ ├── local_custom_executor.rs
│ ├── multiple_tasks.rs
│ ├── tokio_executor.rs
│ └── wasm_bindgen_tests.rs
├── benchmarks/
│ ├── Cargo.toml
│ └── src/
│ ├── lib.rs
│ ├── reactive.rs
│ ├── ssr.rs
│ └── todomvc/
│ ├── leptos.rs
│ ├── mod.rs
│ ├── sycamore.rs
│ ├── tachys.rs
│ ├── tera.rs
│ └── yew.rs
├── cargo-make/
│ ├── check-minimal-versions.toml
│ ├── lint.toml
│ ├── main.toml
│ ├── test.toml
│ └── wasm-test.toml
├── const_str_slice_concat/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ └── src/
│ └── lib.rs
├── docs/
│ ├── COMMON_BUGS.md
│ ├── book_ru/
│ │ ├── .gitignore
│ │ ├── README.md
│ │ ├── book.toml
│ │ ├── mdbook-admonish.css
│ │ └── src/
│ │ ├── 01_introduction.md
│ │ ├── 15_global_state.md
│ │ ├── SUMMARY.md
│ │ ├── appendix_reactive_graph.md
│ │ ├── async/
│ │ │ ├── 10_resources.md
│ │ │ ├── 11_suspense.md
│ │ │ ├── 12_transition.md
│ │ │ ├── 13_actions.md
│ │ │ └── README.md
│ │ ├── csr_wrapping_up.md
│ │ ├── deployment/
│ │ │ ├── README.md
│ │ │ └── binary_size.md
│ │ ├── getting_started/
│ │ │ ├── README.md
│ │ │ ├── community_crates.md
│ │ │ └── leptos_dx.md
│ │ ├── interlude_projecting_children.md
│ │ ├── interlude_styling.md
│ │ ├── islands.md
│ │ ├── metadata.md
│ │ ├── progressive_enhancement/
│ │ │ ├── README.md
│ │ │ └── action_form.md
│ │ ├── reactivity/
│ │ │ ├── 14_create_effect.md
│ │ │ ├── README.md
│ │ │ ├── interlude_functions.md
│ │ │ └── working_with_signals.md
│ │ ├── router/
│ │ │ ├── 16_routes.md
│ │ │ ├── 17_nested_routing.md
│ │ │ ├── 18_params_and_queries.md
│ │ │ ├── 19_a.md
│ │ │ ├── 20_form.md
│ │ │ └── README.md
│ │ ├── server/
│ │ │ ├── 25_server_functions.md
│ │ │ ├── 26_extractors.md
│ │ │ ├── 27_response.md
│ │ │ └── README.md
│ │ ├── ssr/
│ │ │ ├── 21_cargo_leptos.md
│ │ │ ├── 22_life_cycle.md
│ │ │ ├── 23_ssr_modes.md
│ │ │ ├── 24_hydration_bugs.md
│ │ │ └── README.md
│ │ ├── testing.md
│ │ └── view/
│ │ ├── 01_basic_component.md
│ │ ├── 02_dynamic_attributes.md
│ │ ├── 03_components.md
│ │ ├── 04_iteration.md
│ │ ├── 04b_iteration.md
│ │ ├── 05_forms.md
│ │ ├── 06_control_flow.md
│ │ ├── 07_errors.md
│ │ ├── 08_parent_child.md
│ │ ├── 09_component_children.md
│ │ ├── README.md
│ │ └── builder.md
│ └── logos/
│ └── .gitignore
├── either_of/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── examples/
│ ├── Makefile.toml
│ ├── README.md
│ ├── SSR_NOTES.md
│ ├── action-form-error-handling/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.scss
│ ├── axum_js_ssr/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── package.json
│ │ ├── src/
│ │ │ ├── api.rs
│ │ │ ├── app.rs
│ │ │ ├── consts.rs
│ │ │ ├── hljs.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.scss
│ ├── cargo-make/
│ │ ├── cargo-leptos-compress.toml
│ │ ├── cargo-leptos-split-webdriver-test.toml
│ │ ├── cargo-leptos-test.toml
│ │ ├── cargo-leptos-webdriver-test.toml
│ │ ├── cargo-leptos.toml
│ │ ├── clean.toml
│ │ ├── client-process.toml
│ │ ├── compile.toml
│ │ ├── deno-build.toml
│ │ ├── lint.toml
│ │ ├── main.toml
│ │ ├── node.toml
│ │ ├── playwright-test.toml
│ │ ├── playwright-trunk-test.toml
│ │ ├── playwright.toml
│ │ ├── process.toml
│ │ ├── scripts/
│ │ │ └── web-report.sh
│ │ ├── server-process.toml
│ │ ├── trunk_server.toml
│ │ ├── wasm-test.toml
│ │ └── webdriver.toml
│ ├── counter/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── tests/
│ │ └── web.rs
│ ├── counter_isomorphic/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ └── src/
│ │ ├── counters.rs
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── counter_url_query/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── counter_without_macros/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── tests/
│ │ ├── business.rs
│ │ └── web.rs
│ ├── counters/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── .gitignore
│ │ │ ├── package.json
│ │ │ ├── playwright.config.ts
│ │ │ └── tests/
│ │ │ ├── add_1k_counters.spec.ts
│ │ │ ├── add_counter.spec.ts
│ │ │ ├── clear_counters.spec.ts
│ │ │ ├── decrement_count.spec.ts
│ │ │ ├── enter_count.spec.ts
│ │ │ ├── fixtures/
│ │ │ │ └── counters_page.ts
│ │ │ ├── increment_count.spec.ts
│ │ │ ├── remove_counter.spec.ts
│ │ │ └── view_counters.spec.ts
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── tests/
│ │ └── web.rs
│ ├── directives/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── tests/
│ │ └── web.rs
│ ├── error_boundary/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── .gitignore
│ │ │ ├── package.json
│ │ │ ├── playwright.config.ts
│ │ │ └── tests/
│ │ │ ├── clear_number.spec.ts
│ │ │ ├── click_down_arrow.spec.ts
│ │ │ ├── click_up_arrow.spec.ts
│ │ │ ├── fixtures/
│ │ │ │ └── home_page.ts
│ │ │ ├── open_app.spec.ts
│ │ │ └── type_number.spec.ts
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── errors_axum/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── error_template.rs
│ │ │ ├── errors.rs
│ │ │ ├── landing.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style.css
│ ├── fetch/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── hackernews/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── api.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ ├── routes/
│ │ │ │ ├── nav.rs
│ │ │ │ ├── stories.rs
│ │ │ │ ├── story.rs
│ │ │ │ └── users.rs
│ │ │ └── routes.rs
│ │ └── style.css
│ ├── hackernews_axum/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── api.rs
│ │ │ ├── error_template.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ ├── routes/
│ │ │ │ ├── nav.rs
│ │ │ │ ├── stories.rs
│ │ │ │ ├── story.rs
│ │ │ │ └── users.rs
│ │ │ └── routes.rs
│ │ └── style.css
│ ├── hackernews_islands_axum/
│ │ ├── .cargo/
│ │ │ └── config.wasm.toml
│ │ ├── Cargo.toml
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── api.rs
│ │ │ ├── fallback.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ ├── routes/
│ │ │ │ ├── nav.rs
│ │ │ │ ├── stories.rs
│ │ │ │ ├── story.rs
│ │ │ │ └── users.rs
│ │ │ └── routes.rs
│ │ └── style.css
│ ├── hackernews_js_fetch/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── deno.jsonc
│ │ ├── public/
│ │ │ └── style.css
│ │ ├── run.ts
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── api.rs
│ │ ├── lib.rs
│ │ ├── routes/
│ │ │ ├── nav.rs
│ │ │ ├── stories.rs
│ │ │ ├── story.rs
│ │ │ └── users.rs
│ │ └── routes.rs
│ ├── islands/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style.css
│ ├── islands_router/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── mock_data.json
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style.css
│ ├── js-framework-benchmark/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── tests/
│ │ └── web.rs
│ ├── lazy_routes/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── Cargo.toml
│ │ │ ├── Makefile.toml
│ │ │ ├── README.md
│ │ │ ├── features/
│ │ │ │ ├── basic.feature
│ │ │ │ ├── duplicate_name.feature
│ │ │ │ └── shared_chunks.feature
│ │ │ └── tests/
│ │ │ ├── app_suite.rs
│ │ │ └── fixtures/
│ │ │ ├── action.rs
│ │ │ ├── check.rs
│ │ │ ├── find.rs
│ │ │ ├── mod.rs
│ │ │ └── world/
│ │ │ ├── action_steps.rs
│ │ │ ├── check_steps.rs
│ │ │ └── mod.rs
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.scss
│ ├── parent_child/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── portal/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── tests/
│ │ └── web.rs
│ ├── regression/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── Cargo.toml
│ │ │ ├── Makefile.toml
│ │ │ ├── README.md
│ │ │ ├── features/
│ │ │ │ ├── issue_4005.feature
│ │ │ │ ├── issue_4088.feature
│ │ │ │ ├── issue_4217.feature
│ │ │ │ ├── issue_4251.feature
│ │ │ │ ├── issue_4285.feature
│ │ │ │ ├── issue_4296.feature
│ │ │ │ ├── issue_4324.feature
│ │ │ │ ├── issue_4492.feature
│ │ │ │ ├── pr_4015.feature
│ │ │ │ └── pr_4091.feature
│ │ │ └── tests/
│ │ │ ├── app_suite.rs
│ │ │ └── fixtures/
│ │ │ ├── action.rs
│ │ │ ├── check.rs
│ │ │ ├── find.rs
│ │ │ ├── mod.rs
│ │ │ └── world/
│ │ │ ├── action_steps.rs
│ │ │ ├── check_steps.rs
│ │ │ └── mod.rs
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── issue_4005.rs
│ │ │ ├── issue_4088.rs
│ │ │ ├── issue_4217.rs
│ │ │ ├── issue_4285.rs
│ │ │ ├── issue_4296.rs
│ │ │ ├── issue_4324.rs
│ │ │ ├── issue_4492.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ ├── pr_4015.rs
│ │ │ └── pr_4091.rs
│ │ └── style/
│ │ └── main.scss
│ ├── router/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── package.json
│ │ │ ├── playwright.config.ts
│ │ │ └── tests/
│ │ │ └── router.spec.ts
│ │ ├── index.html
│ │ ├── package.json
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── api.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style.css
│ ├── server_fns_axum/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── error_template.rs
│ │ │ ├── errors.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ └── middleware.rs
│ │ ├── style.css
│ │ └── watched_files/
│ │ └── .gitkeep
│ ├── slots/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── spread/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── ssr_modes/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.scss
│ ├── ssr_modes_axum/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.scss
│ ├── static_routing/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── posts/
│ │ │ ├── post1.md
│ │ │ ├── post2.md
│ │ │ ├── post3.md
│ │ │ └── post4.md
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.scss
│ ├── stores/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── subsecond_hot_patch/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── Dioxus.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── assets/
│ │ │ └── main.css
│ │ └── src/
│ │ └── main.rs
│ ├── suspense_tests/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── Cargo.toml
│ │ │ ├── Makefile.toml
│ │ │ ├── README.md
│ │ │ ├── features/
│ │ │ │ ├── check_aria_current.feature
│ │ │ │ ├── check_instrumented.feature
│ │ │ │ ├── check_instrumented_issue_3719.feature
│ │ │ │ ├── check_instrumented_suspense_resource.feature
│ │ │ │ ├── click_inside_component_count.feature
│ │ │ │ ├── click_nested_count.feature
│ │ │ │ ├── click_nested_inside_count.feature
│ │ │ │ ├── click_no_resources_count_1.feature
│ │ │ │ ├── click_no_resources_count_2.feature
│ │ │ │ ├── click_parallel_count_1.feature
│ │ │ │ ├── click_parallel_count_2.feature
│ │ │ │ ├── click_single_count.feature
│ │ │ │ ├── open_app.feature
│ │ │ │ ├── view_inside_component.feature
│ │ │ │ ├── view_nested.feature
│ │ │ │ ├── view_nested_inside.feature
│ │ │ │ ├── view_no_resources.feature
│ │ │ │ ├── view_parallel.feature
│ │ │ │ └── view_single.feature
│ │ │ └── tests/
│ │ │ ├── app_suite.rs
│ │ │ └── fixtures/
│ │ │ ├── action.rs
│ │ │ ├── check.rs
│ │ │ ├── find.rs
│ │ │ ├── mod.rs
│ │ │ └── world/
│ │ │ ├── action_steps.rs
│ │ │ ├── check_steps.rs
│ │ │ └── mod.rs
│ │ └── src/
│ │ ├── app.rs
│ │ ├── instrumented.rs
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── tailwind_actix/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── end2end/
│ │ │ ├── package.json
│ │ │ ├── playwright.config.ts
│ │ │ └── tests/
│ │ │ └── example.spec.ts
│ │ ├── input.css
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── app.rs
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── tailwind_axum/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── end2end/
│ │ │ ├── package.json
│ │ │ ├── playwright.config.ts
│ │ │ └── tests/
│ │ │ └── example.spec.ts
│ │ ├── input.css
│ │ ├── package.json
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── app.rs
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── tailwind_csr/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── Trunk.toml
│ │ ├── end2end/
│ │ │ ├── package.json
│ │ │ ├── playwright.config.ts
│ │ │ └── tests/
│ │ │ └── example.spec.ts
│ │ ├── index.html
│ │ ├── input.css
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── app.rs
│ │ └── main.rs
│ ├── timer/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── todo_app_sqlite/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── Cargo.toml
│ │ │ ├── Makefile.toml
│ │ │ ├── README.md
│ │ │ ├── features/
│ │ │ │ ├── add_todo.feature
│ │ │ │ ├── delete_todo.feature
│ │ │ │ └── open_app.feature
│ │ │ └── tests/
│ │ │ ├── app_suite.rs
│ │ │ └── fixtures/
│ │ │ ├── action.rs
│ │ │ ├── check.rs
│ │ │ ├── find.rs
│ │ │ ├── mod.rs
│ │ │ └── world/
│ │ │ ├── action_steps.rs
│ │ │ ├── check_steps.rs
│ │ │ └── mod.rs
│ │ ├── migrations/
│ │ │ └── 20221118172000_create_todo_table.sql
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ └── todo.rs
│ │ └── style.css
│ ├── todo_app_sqlite_axum/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── Cargo.toml
│ │ │ ├── Makefile.toml
│ │ │ ├── README.md
│ │ │ ├── features/
│ │ │ │ ├── add_todo.feature
│ │ │ │ ├── delete_todo.feature
│ │ │ │ └── open_app.feature
│ │ │ └── tests/
│ │ │ ├── app_suite.rs
│ │ │ └── fixtures/
│ │ │ ├── action.rs
│ │ │ ├── check.rs
│ │ │ ├── find.rs
│ │ │ ├── mod.rs
│ │ │ └── world/
│ │ │ ├── action_steps.rs
│ │ │ ├── check_steps.rs
│ │ │ └── mod.rs
│ │ ├── migrations/
│ │ │ └── 20221118172000_create_todo_table.sql
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── error_template.rs
│ │ │ ├── errors.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ └── todo.rs
│ │ └── style.css
│ ├── todo_app_sqlite_csr/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── e2e/
│ │ │ ├── Cargo.toml
│ │ │ ├── Makefile.toml
│ │ │ ├── README.md
│ │ │ ├── features/
│ │ │ │ ├── add_todo.feature
│ │ │ │ ├── delete_todo.feature
│ │ │ │ └── open_app.feature
│ │ │ └── tests/
│ │ │ ├── app_suite.rs
│ │ │ └── fixtures/
│ │ │ ├── action.rs
│ │ │ ├── check.rs
│ │ │ ├── find.rs
│ │ │ ├── mod.rs
│ │ │ └── world/
│ │ │ ├── action_steps.rs
│ │ │ ├── check_steps.rs
│ │ │ └── mod.rs
│ │ ├── migrations/
│ │ │ └── 20221118172000_create_todo_table.sql
│ │ ├── rust-toolchain.toml
│ │ ├── src/
│ │ │ ├── error_template.rs
│ │ │ ├── errors.rs
│ │ │ ├── fallback.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ └── todo.rs
│ │ └── style.css
│ ├── todomvc/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ ├── package.json
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ └── websocket/
│ ├── Cargo.toml
│ ├── LICENSE
│ ├── Makefile.toml
│ ├── README.md
│ ├── e2e/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── features/
│ │ │ ├── echo_client_error.feature
│ │ │ ├── echo_server_error.feature
│ │ │ ├── echo_text.feature
│ │ │ └── open_app.feature
│ │ └── tests/
│ │ ├── app_suite.rs
│ │ └── fixtures/
│ │ ├── action.rs
│ │ ├── check.rs
│ │ ├── find.rs
│ │ ├── mod.rs
│ │ └── world/
│ │ ├── action_steps.rs
│ │ ├── check_steps.rs
│ │ └── mod.rs
│ ├── src/
│ │ ├── lib.rs
│ │ ├── main.rs
│ │ └── websocket.rs
│ └── style.css
├── flake.nix
├── hydration_context/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ └── src/
│ ├── csr.rs
│ ├── hydrate.rs
│ ├── lib.rs
│ └── ssr.rs
├── integrations/
│ ├── actix/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── src/
│ │ │ └── lib.rs
│ │ └── tests/
│ │ └── extract_routes.rs
│ ├── axum/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ └── service.rs
│ │ └── tests/
│ │ ├── axum_integration.rs
│ │ └── service_mode/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.css
│ └── utils/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ └── src/
│ └── lib.rs
├── leptos/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── build.rs
│ ├── src/
│ │ ├── animated_show.rs
│ │ ├── attribute_interceptor.rs
│ │ ├── await_.rs
│ │ ├── children.rs
│ │ ├── component.rs
│ │ ├── error_boundary.rs
│ │ ├── for_loop.rs
│ │ ├── form.rs
│ │ ├── from_form_data.rs
│ │ ├── hydration/
│ │ │ ├── hydration_script.js
│ │ │ ├── island_script.js
│ │ │ ├── islands_routing.js
│ │ │ ├── mod.rs
│ │ │ └── reload_script.js
│ │ ├── into_view.rs
│ │ ├── lib.rs
│ │ ├── logging.rs
│ │ ├── mount.rs
│ │ ├── nonce.rs
│ │ ├── portal.rs
│ │ ├── provider.rs
│ │ ├── show.rs
│ │ ├── show_let.rs
│ │ ├── subsecond.rs
│ │ ├── suspense_component.rs
│ │ ├── text_prop.rs
│ │ └── transition.rs
│ └── tests/
│ ├── pr_4061.rs
│ └── ssr.rs
├── leptos_config/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── src/
│ │ ├── errors.rs
│ │ ├── lib.rs
│ │ └── tests.rs
│ └── tests/
│ └── config.rs
├── leptos_dom/
│ ├── .cargo/
│ │ └── config.toml
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── examples/
│ │ ├── hydration-test/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ ├── test-bench/
│ │ │ ├── Cargo.toml
│ │ │ ├── index.html
│ │ │ └── src/
│ │ │ └── main.rs
│ │ └── view-tests/
│ │ ├── Cargo.toml
│ │ ├── index.html
│ │ └── src/
│ │ └── main.rs
│ └── src/
│ ├── helpers.rs
│ ├── lib.rs
│ ├── logging.rs
│ └── macro_helpers/
│ ├── mod.rs
│ └── tracing_property.rs
├── leptos_hot_reload/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ └── src/
│ ├── diff.rs
│ ├── lib.rs
│ ├── node.rs
│ ├── parsing.rs
│ └── patch.js
├── leptos_macro/
│ ├── .gitignore
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── build.rs
│ ├── example/
│ │ ├── Cargo.toml
│ │ └── src/
│ │ └── lib.rs
│ ├── src/
│ │ ├── component.rs
│ │ ├── lazy.rs
│ │ ├── lib.rs
│ │ ├── memo.rs
│ │ ├── params.rs
│ │ ├── slice.rs
│ │ ├── slot.rs
│ │ └── view/
│ │ ├── component_builder.rs
│ │ ├── mod.rs
│ │ ├── slot_helper.rs
│ │ ├── snapshots/
│ │ │ └── leptos_macro__view__tests__client_template__full_span__counter_component.snap
│ │ └── utils.rs
│ └── tests/
│ ├── component.rs
│ ├── memo/
│ │ ├── red.rs
│ │ └── red.stderr
│ ├── memo.rs
│ ├── params.rs
│ ├── server.rs
│ ├── slice/
│ │ ├── red.rs
│ │ └── red.stderr
│ ├── slice.rs
│ ├── ui/
│ │ ├── component.rs
│ │ ├── component.stderr
│ │ ├── component_absolute.rs
│ │ ├── component_absolute.stderr
│ │ ├── server.rs
│ │ └── server.stderr
│ └── ui.rs
├── leptos_server/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ └── src/
│ ├── action.rs
│ ├── lib.rs
│ ├── local_resource.rs
│ ├── multi_action.rs
│ ├── once_resource.rs
│ ├── resource.rs
│ ├── serializers.rs
│ └── shared.rs
├── meta/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ └── src/
│ ├── body.rs
│ ├── html.rs
│ ├── lib.rs
│ ├── link.rs
│ ├── meta_tags.rs
│ ├── script.rs
│ ├── style.rs
│ ├── stylesheet.rs
│ └── title.rs
├── next_tuple/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── oco/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── or_poisoned/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── projects/
│ ├── README.md
│ ├── bevy3d_ui/
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── index.html
│ │ └── src/
│ │ ├── demos/
│ │ │ ├── bevydemo1/
│ │ │ │ ├── eventqueue/
│ │ │ │ │ ├── events.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ └── plugin.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── scene.rs
│ │ │ │ └── state.rs
│ │ │ └── mod.rs
│ │ ├── main.rs
│ │ └── routes/
│ │ ├── demo1.rs
│ │ └── mod.rs
│ ├── counter_dwarf_debug/
│ │ ├── .gitignore
│ │ ├── .vscode/
│ │ │ ├── launch.json
│ │ │ └── tasks.json
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── Trunk.toml
│ │ ├── index.html
│ │ ├── rust-toolchain.toml
│ │ └── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── hexagonal-architecture/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── end2end/
│ │ │ ├── package.json
│ │ │ ├── playwright.config.ts
│ │ │ ├── tests/
│ │ │ │ └── example.spec.ts
│ │ │ └── tsconfig.json
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── config.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ ├── middleware.rs
│ │ │ ├── server_types.rs
│ │ │ ├── trait_impl.rs
│ │ │ ├── traits.rs
│ │ │ └── ui_types.rs
│ │ └── style/
│ │ └── main.scss
│ ├── login_with_token_csr_only/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── api-boundary/
│ │ │ ├── Cargo.toml
│ │ │ ├── Makefile.toml
│ │ │ └── src/
│ │ │ └── lib.rs
│ │ ├── client/
│ │ │ ├── Cargo.toml
│ │ │ ├── Makefile.toml
│ │ │ ├── Trunk.toml
│ │ │ ├── index.html
│ │ │ └── src/
│ │ │ ├── api.rs
│ │ │ ├── components/
│ │ │ │ ├── credentials.rs
│ │ │ │ ├── mod.rs
│ │ │ │ └── navbar.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ └── pages/
│ │ │ ├── home.rs
│ │ │ ├── login.rs
│ │ │ ├── mod.rs
│ │ │ └── register.rs
│ │ └── server/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ └── src/
│ │ ├── adapters.rs
│ │ ├── application.rs
│ │ └── main.rs
│ ├── meilisearch-searchbar/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── data_set.csv
│ │ └── src/
│ │ ├── fallback.rs
│ │ ├── lib.rs
│ │ └── main.rs
│ ├── nginx-mpmc/
│ │ ├── .gitignore
│ │ ├── README.md
│ │ ├── app-1/
│ │ │ ├── .gitignore
│ │ │ ├── Cargo.toml
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── src/
│ │ │ │ ├── app.rs
│ │ │ │ ├── error_template.rs
│ │ │ │ ├── fileserv.rs
│ │ │ │ ├── lib.rs
│ │ │ │ └── main.rs
│ │ │ └── style/
│ │ │ └── main.scss
│ │ ├── app-2/
│ │ │ ├── .gitignore
│ │ │ ├── Cargo.toml
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── src/
│ │ │ │ ├── app.rs
│ │ │ │ ├── error_template.rs
│ │ │ │ ├── fileserv.rs
│ │ │ │ ├── lib.rs
│ │ │ │ └── main.rs
│ │ │ └── style/
│ │ │ └── main.scss
│ │ ├── kill.sh
│ │ ├── nginx.conf
│ │ ├── nginx_linux.conf
│ │ ├── run.sh
│ │ ├── run_linux.sh
│ │ ├── shared-server-1/
│ │ │ ├── .gitignore
│ │ │ ├── Cargo.toml
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── src/
│ │ │ │ ├── lib.rs
│ │ │ │ └── main.rs
│ │ │ └── style/
│ │ │ └── main.scss
│ │ └── shared-server-2/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.scss
│ ├── openapi-openai-api-swagger-ui/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── end2end/
│ │ │ ├── package.json
│ │ │ ├── playwright.config.ts
│ │ │ └── tests/
│ │ │ └── example.spec.ts
│ │ ├── src/
│ │ │ ├── app.rs
│ │ │ ├── error_template.rs
│ │ │ ├── fileserv.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ └── open_ai.rs
│ │ └── style/
│ │ └── main.scss
│ ├── ory-kratos/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── app/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ ├── auth/
│ │ │ │ ├── extractors.rs
│ │ │ │ ├── kratos_error.rs
│ │ │ │ ├── kratos_html.rs
│ │ │ │ ├── login.rs
│ │ │ │ ├── logout.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── recovery.rs
│ │ │ │ ├── registration.rs
│ │ │ │ ├── session.rs
│ │ │ │ ├── settings.rs
│ │ │ │ └── verification.rs
│ │ │ ├── database_calls.rs
│ │ │ ├── error_template.rs
│ │ │ ├── lib.rs
│ │ │ └── posts/
│ │ │ ├── create_posts.rs
│ │ │ ├── mod.rs
│ │ │ ├── post.rs
│ │ │ └── posts_page.rs
│ │ ├── docker-compose.yml
│ │ ├── e2e/
│ │ │ ├── Cargo.toml
│ │ │ ├── features/
│ │ │ │ ├── 0_test.feature
│ │ │ │ ├── 1_register.feature
│ │ │ │ ├── 2_login.feature
│ │ │ │ ├── 3_logout.feature
│ │ │ │ ├── 4_recovery.feature
│ │ │ │ ├── 5_settings.feature
│ │ │ │ ├── 6_add_post.feature
│ │ │ │ └── 7_edit_post.feature
│ │ │ └── tests/
│ │ │ ├── app_suite.rs
│ │ │ └── fixtures/
│ │ │ ├── mod.rs
│ │ │ └── steps.rs
│ │ ├── frontend/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── lib.rs
│ │ ├── ids/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── lib.rs
│ │ ├── kratos/
│ │ │ ├── email.schema.json
│ │ │ └── kratos.yaml
│ │ ├── migrations/
│ │ │ ├── 01_create_users.sql
│ │ │ ├── 02_create_posts.sql
│ │ │ └── 03_create_post_permissions.sql
│ │ ├── server/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ ├── extract_session.rs
│ │ │ ├── fileserv.rs
│ │ │ └── main.rs
│ │ └── style/
│ │ └── main.scss
│ ├── session_auth_axum/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── flake.nix
│ │ ├── migrations/
│ │ │ └── 20230226000000_create_todo_table.sql
│ │ ├── src/
│ │ │ ├── auth.rs
│ │ │ ├── error_template.rs
│ │ │ ├── errors.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ ├── state.rs
│ │ │ └── todo.rs
│ │ └── style.css
│ ├── sitemap_axum/
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── init/
│ │ │ └── schema.sql
│ │ ├── sitemap-index.xml
│ │ ├── sitemap-static.xml
│ │ └── src/
│ │ ├── app.rs
│ │ ├── error_template.rs
│ │ ├── fileserv.rs
│ │ ├── lib.rs
│ │ ├── main.rs
│ │ └── sitemap.rs
│ ├── sso_auth_axum/
│ │ ├── Cargo.toml
│ │ ├── LICENSE
│ │ ├── Makefile.toml
│ │ ├── README.md
│ │ ├── flake.nix
│ │ ├── migrations/
│ │ │ └── 20231217000000_create_tables.sql
│ │ ├── src/
│ │ │ ├── auth.rs
│ │ │ ├── error_template.rs
│ │ │ ├── fallback.rs
│ │ │ ├── lib.rs
│ │ │ ├── main.rs
│ │ │ ├── sign_in_sign_up.rs
│ │ │ └── state.rs
│ │ └── style.css
│ └── tauri-from-scratch/
│ ├── .gitignore
│ ├── Cargo.toml
│ ├── README.md
│ ├── Trunk.toml
│ ├── src-orig/
│ │ ├── Cargo.toml
│ │ ├── index.html
│ │ └── src/
│ │ ├── app.rs
│ │ ├── fallback.rs
│ │ ├── lib.rs
│ │ └── main.rs
│ └── src-tauri/
│ ├── Cargo.toml
│ ├── build.rs
│ ├── src/
│ │ ├── lib.rs
│ │ └── main.rs
│ └── tauri.conf.json
├── reactive_graph/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ ├── build.rs
│ ├── src/
│ │ ├── actions/
│ │ │ ├── action.rs
│ │ │ ├── mod.rs
│ │ │ └── multi_action.rs
│ │ ├── callback.rs
│ │ ├── channel.rs
│ │ ├── computed/
│ │ │ ├── arc_memo.rs
│ │ │ ├── async_derived/
│ │ │ │ ├── arc_async_derived.rs
│ │ │ │ ├── async_derived.rs
│ │ │ │ ├── future_impls.rs
│ │ │ │ ├── inner.rs
│ │ │ │ └── mod.rs
│ │ │ ├── inner.rs
│ │ │ ├── memo.rs
│ │ │ └── selector.rs
│ │ ├── computed.rs
│ │ ├── diagnostics.rs
│ │ ├── effect/
│ │ │ ├── effect.rs
│ │ │ ├── effect_function.rs
│ │ │ ├── immediate.rs
│ │ │ ├── inner.rs
│ │ │ └── render_effect.rs
│ │ ├── effect.rs
│ │ ├── graph/
│ │ │ ├── node.rs
│ │ │ ├── sets.rs
│ │ │ ├── source.rs
│ │ │ └── subscriber.rs
│ │ ├── graph.rs
│ │ ├── into_reactive_value.rs
│ │ ├── lib.rs
│ │ ├── nightly.rs
│ │ ├── owner/
│ │ │ ├── arc_stored_value.rs
│ │ │ ├── arena.rs
│ │ │ ├── arena_item.rs
│ │ │ ├── context.rs
│ │ │ ├── storage.rs
│ │ │ └── stored_value.rs
│ │ ├── owner.rs
│ │ ├── send_wrapper_ext.rs
│ │ ├── serde.rs
│ │ ├── signal/
│ │ │ ├── arc_read.rs
│ │ │ ├── arc_rw.rs
│ │ │ ├── arc_trigger.rs
│ │ │ ├── arc_write.rs
│ │ │ ├── guards.rs
│ │ │ ├── mapped.rs
│ │ │ ├── read.rs
│ │ │ ├── rw.rs
│ │ │ ├── subscriber_traits.rs
│ │ │ ├── trigger.rs
│ │ │ └── write.rs
│ │ ├── signal.rs
│ │ ├── trait_options.rs
│ │ ├── traits.rs
│ │ ├── transition.rs
│ │ └── wrappers.rs
│ └── tests/
│ ├── async_derived.rs
│ ├── cleanup.rs
│ ├── effect.rs
│ ├── effect_immediate.rs
│ ├── memo.rs
│ ├── signal.rs
│ └── watch.rs
├── reactive_stores/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ └── src/
│ ├── arc_field.rs
│ ├── deref.rs
│ ├── field.rs
│ ├── iter.rs
│ ├── keyed.rs
│ ├── len.rs
│ ├── lib.rs
│ ├── option.rs
│ ├── patch.rs
│ ├── path.rs
│ ├── serde.rs
│ ├── slotmap.rs
│ ├── store_field.rs
│ └── subfield.rs
├── reactive_stores_macro/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── router/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── build.rs
│ └── src/
│ ├── components.rs
│ ├── flat_router.rs
│ ├── form.rs
│ ├── generate_route_list.rs
│ ├── hooks.rs
│ ├── lib.rs
│ ├── link.rs
│ ├── location/
│ │ ├── history.rs
│ │ ├── mod.rs
│ │ └── server.rs
│ ├── matching/
│ │ ├── any_choose_view.rs
│ │ ├── choose_view.rs
│ │ ├── horizontal/
│ │ │ ├── mod.rs
│ │ │ ├── param_segments.rs
│ │ │ ├── static_segment.rs
│ │ │ └── tuples.rs
│ │ ├── mod.rs
│ │ ├── nested/
│ │ │ ├── any_nested_match.rs
│ │ │ ├── any_nested_route.rs
│ │ │ ├── mod.rs
│ │ │ └── tuples.rs
│ │ ├── path_segment.rs
│ │ ├── resolve_path.rs
│ │ └── vertical/
│ │ └── mod.rs
│ ├── method.rs
│ ├── navigate.rs
│ ├── nested_router.rs
│ ├── params.rs
│ ├── reactive.rs
│ ├── ssr_mode.rs
│ └── static_routes.rs
├── router_macro/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── src/
│ │ └── lib.rs
│ └── tests/
│ └── path.rs
├── rustfmt.toml
├── scripts/
│ ├── axum_integration_service_mode.bat
│ ├── axum_integration_service_mode.sh
│ ├── bump.sh
│ └── update_nightly.sh
├── server_fn/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── build.rs
│ ├── server_fn_macro_default/
│ │ ├── Cargo.toml
│ │ ├── Makefile.toml
│ │ └── src/
│ │ └── lib.rs
│ ├── src/
│ │ ├── client.rs
│ │ ├── codec/
│ │ │ ├── bitcode.rs
│ │ │ ├── bitcode_serde.rs
│ │ │ ├── cbor.rs
│ │ │ ├── json.rs
│ │ │ ├── mod.rs
│ │ │ ├── msgpack.rs
│ │ │ ├── multipart.rs
│ │ │ ├── patch.rs
│ │ │ ├── post.rs
│ │ │ ├── postcard.rs
│ │ │ ├── put.rs
│ │ │ ├── rkyv.rs
│ │ │ ├── serde_lite.rs
│ │ │ ├── stream.rs
│ │ │ └── url.rs
│ │ ├── error.rs
│ │ ├── lib.rs
│ │ ├── middleware/
│ │ │ └── mod.rs
│ │ ├── redirect.rs
│ │ ├── request/
│ │ │ ├── actix.rs
│ │ │ ├── axum.rs
│ │ │ ├── browser.rs
│ │ │ ├── generic.rs
│ │ │ ├── mod.rs
│ │ │ ├── reqwest.rs
│ │ │ └── spin.rs
│ │ ├── response/
│ │ │ ├── actix.rs
│ │ │ ├── browser.rs
│ │ │ ├── generic.rs
│ │ │ ├── http.rs
│ │ │ ├── mod.rs
│ │ │ └── reqwest.rs
│ │ └── server.rs
│ └── tests/
│ ├── invalid/
│ │ ├── aliased_return_full.rs
│ │ ├── aliased_return_full.stderr
│ │ ├── aliased_return_none.rs
│ │ ├── aliased_return_none.stderr
│ │ ├── aliased_return_part.rs
│ │ ├── aliased_return_part.stderr
│ │ ├── empty_return.rs
│ │ ├── empty_return.stderr
│ │ ├── no_return.rs
│ │ ├── no_return.stderr
│ │ ├── not_async.rs
│ │ ├── not_async.stderr
│ │ ├── not_result.rs
│ │ └── not_result.stderr
│ ├── server_macro.rs
│ └── valid/
│ ├── aliased_return_full.rs
│ ├── aliased_return_none.rs
│ ├── aliased_return_part.rs
│ ├── custom_error_aliased_return_full.rs
│ ├── custom_error_aliased_return_none.rs
│ └── custom_error_aliased_return_part.rs
├── server_fn_macro/
│ ├── Cargo.toml
│ ├── Makefile.toml
│ ├── build.rs
│ └── src/
│ └── lib.rs
└── tachys/
├── Cargo.toml
├── Makefile.toml
├── build.rs
└── src/
├── dom.rs
├── erased.rs
├── html/
│ ├── attribute/
│ │ ├── any_attribute.rs
│ │ ├── aria.rs
│ │ ├── custom.rs
│ │ ├── global.rs
│ │ ├── key.rs
│ │ ├── maybe_next_attr_erasure_macros.rs
│ │ ├── mod.rs
│ │ └── value.rs
│ ├── class.rs
│ ├── directive.rs
│ ├── element/
│ │ ├── custom.rs
│ │ ├── element_ext.rs
│ │ ├── elements.rs
│ │ ├── inner_html.rs
│ │ └── mod.rs
│ ├── event.rs
│ ├── islands.rs
│ ├── mod.rs
│ ├── node_ref.rs
│ ├── property.rs
│ └── style.rs
├── hydration.rs
├── lib.rs
├── mathml/
│ └── mod.rs
├── oco.rs
├── reactive_graph/
│ ├── bind.rs
│ ├── class.rs
│ ├── inner_html.rs
│ ├── mod.rs
│ ├── node_ref.rs
│ ├── owned.rs
│ ├── property.rs
│ ├── style.rs
│ └── suspense.rs
├── renderer/
│ ├── dom.rs
│ ├── mock_dom.rs
│ ├── mod.rs
│ └── sledgehammer.rs
├── ssr/
│ └── mod.rs
├── svg/
│ └── mod.rs
└── view/
├── add_attr.rs
├── any_view.rs
├── either.rs
├── error_boundary.rs
├── fragment.rs
├── iterators.rs
├── keyed.rs
├── mod.rs
├── primitives.rs
├── static_types.rs
├── strings.rs
├── template.rs
└── tuples.rs
Showing preview only (650K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (8394 symbols across 654 files)
FILE: any_error/src/lib.rs
type Error (line 23) | pub struct Error(Arc<dyn error::Error + Send + Sync>);
method into_inner (line 27) | pub fn into_inner(self) -> Arc<dyn error::Error + Send + Sync> {
type Target (line 33) | type Target = Arc<dyn error::Error + Send + Sync>;
method deref (line 35) | fn deref(&self) -> &Self::Target {
method fmt (line 41) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
method from (line 50) | fn from(value: T) -> Self {
type ErrorHook (line 61) | pub trait ErrorHook: Send + Sync {
method throw (line 63) | fn throw(&self, error: Error) -> ErrorId;
method clear (line 66) | fn clear(&self, id: &ErrorId);
type ErrorId (line 72) | pub struct ErrorId(usize);
method from (line 81) | fn from(value: usize) -> Self {
method fmt (line 75) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
type ResetErrorHookOnDrop (line 91) | pub struct ResetErrorHookOnDrop(Option<Arc<dyn ErrorHook>>);
method drop (line 94) | fn drop(&mut self) {
function get_error_hook (line 100) | pub fn get_error_hook() -> Option<Arc<dyn ErrorHook>> {
function set_error_hook (line 105) | pub fn set_error_hook(hook: Arc<dyn ErrorHook>) -> ResetErrorHookOnDrop {
function throw (line 112) | pub fn throw(error: impl Into<Error>) -> ErrorId {
function clear (line 119) | pub fn clear(id: &ErrorId) {
function new (line 138) | pub fn new(inner: Fut) -> Self {
type Output (line 150) | type Output = Fut::Output;
method poll (line 152) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
type MyError (line 168) | struct MyError;
method fmt (line 171) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
function test_from (line 179) | fn test_from() {
FILE: any_spawner/src/lib.rs
type PinnedFuture (line 34) | pub type PinnedFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
type PinnedLocalFuture (line 36) | pub type PinnedLocalFuture<T> = Pin<Box<dyn Future<Output = T>>>;
type SpawnFn (line 39) | type SpawnFn = fn(PinnedFuture<()>);
type SpawnLocalFn (line 41) | type SpawnLocalFn = fn(PinnedLocalFuture<()>);
type PollLocalFn (line 43) | type PollLocalFn = fn();
type ExecutorFns (line 47) | struct ExecutorFns {
function no_op_poll (line 60) | fn no_op_poll() {}
function no_op_spawn (line 65) | fn no_op_spawn(_: PinnedFuture<()>) {
function no_op_spawn (line 78) | fn no_op_spawn(_: PinnedFuture<()>) {
function no_op_spawn_local (line 87) | fn no_op_spawn_local(_: PinnedLocalFuture<()>) {
type ExecutorError (line 96) | pub enum ExecutorError {
type Executor (line 103) | pub struct Executor;
method spawn (line 112) | pub fn spawn(fut: impl Future<Output = ()> + Send + 'static) {
method spawn_local (line 129) | pub fn spawn_local(fut: impl Future<Output = ()> + 'static) {
method tick (line 143) | pub async fn tick() {
method poll_local (line 162) | pub fn poll_local() {
method init_tokio (line 178) | pub fn init_tokio() -> Result<(), ExecutorError> {
method init_wasm_bindgen (line 201) | pub fn init_wasm_bindgen() -> Result<(), ExecutorError> {
method init_glib (line 222) | pub fn init_glib() -> Result<(), ExecutorError> {
method init_futures_executor (line 248) | pub fn init_futures_executor() -> Result<(), ExecutorError> {
method init_async_executor (line 309) | pub fn init_async_executor() -> Result<(), ExecutorError> {
method init_custom_executor (line 348) | pub fn init_custom_executor(
method init_local_custom_executor (line 394) | pub fn init_local_custom_executor(
type CustomExecutor (line 441) | pub trait CustomExecutor {
method spawn (line 443) | fn spawn(&self, fut: PinnedFuture<()>);
method spawn_local (line 445) | fn spawn_local(&self, fut: PinnedLocalFuture<()>);
method poll_local (line 449) | fn poll_local(&self);
function test_object_safety (line 454) | fn test_object_safety(_: Box<dyn CustomExecutor + Send + Sync>) {}
function handle_uninitialized_spawn (line 460) | fn handle_uninitialized_spawn(_fut: PinnedFuture<()>) {
function handle_uninitialized_spawn_local (line 490) | fn handle_uninitialized_spawn_local(_fut: PinnedLocalFuture<()>) {
FILE: any_spawner/tests/already_set_error.rs
function test_already_set_error (line 4) | fn test_already_set_error() {
FILE: any_spawner/tests/async_executor.rs
type TestExecutor (line 10) | struct TestExecutor {
method new (line 15) | fn new() -> Self {
method spawn (line 21) | fn spawn<F>(&self, future: F)
method run_all (line 28) | fn run_all(&self) {
function test_async_executor (line 51) | fn test_async_executor() {
FILE: any_spawner/tests/custom_executor.rs
function test_custom_executor (line 8) | fn test_custom_executor() {
FILE: any_spawner/tests/custom_runtime.rs
function can_create_custom_executor (line 6) | fn can_create_custom_executor() {
FILE: any_spawner/tests/executor_tick.rs
function test_executor_tick (line 10) | async fn test_executor_tick() {
FILE: any_spawner/tests/futures_executor.rs
function test_futures_executor (line 11) | fn test_futures_executor() {
FILE: any_spawner/tests/futures_runtime.rs
function can_spawn_local_future (line 7) | fn can_spawn_local_future() {
function can_make_local_progress (line 19) | fn can_make_local_progress() {
FILE: any_spawner/tests/glib.rs
function run_on_glib_context (line 19) | fn run_on_glib_context<F>(fut: F)
function run_local_on_glib_context (line 38) | fn run_local_on_glib_context<F>(fut: F)
function test_glib_spawn (line 60) | fn test_glib_spawn() {
function test_glib_spawn_local (line 85) | fn test_glib_spawn_local() {
function test_glib_tick (line 120) | fn test_glib_tick() {
function test_glib_poll_local_is_no_op (line 142) | fn test_glib_poll_local_is_no_op() {
FILE: any_spawner/tests/local_custom_executor.rs
function test_local_custom_executor (line 8) | fn test_local_custom_executor() {
FILE: any_spawner/tests/multiple_tasks.rs
function test_multiple_tasks (line 8) | async fn test_multiple_tasks() {
FILE: any_spawner/tests/tokio_executor.rs
function test_tokio_executor (line 7) | async fn test_tokio_executor() {
FILE: any_spawner/tests/wasm_bindgen_tests.rs
function test_wasm_bindgen_spawn_local (line 14) | async fn test_wasm_bindgen_spawn_local() {
function test_wasm_bindgen_tick (line 34) | async fn test_wasm_bindgen_tick() {
function test_multiple_wasm_bindgen_tasks (line 54) | async fn test_multiple_wasm_bindgen_tasks() {
function test_wasm_bindgen_spawn_errors (line 81) | fn test_wasm_bindgen_spawn_errors() {
FILE: benchmarks/src/reactive.rs
function leptos_deep_creation (line 5) | fn leptos_deep_creation(b: &mut Bencher) {
function leptos_deep_update (line 26) | fn leptos_deep_update(b: &mut Bencher) {
function leptos_narrowing_down (line 48) | fn leptos_narrowing_down(b: &mut Bencher) {
function leptos_fanning_out (line 65) | fn leptos_fanning_out(b: &mut Bencher) {
function leptos_narrowing_update (line 83) | fn leptos_narrowing_update(b: &mut Bencher) {
function l0410_deep_creation (line 115) | fn l0410_deep_creation(b: &mut Bencher) {
function l0410_deep_update (line 138) | fn l0410_deep_update(b: &mut Bencher) {
function l0410_narrowing_down (line 163) | fn l0410_narrowing_down(b: &mut Bencher) {
function l0410_fanning_out (line 186) | fn l0410_fanning_out(b: &mut Bencher) {
function l0410_narrowing_update (line 206) | fn l0410_narrowing_update(b: &mut Bencher) {
function l0410_scope_creation_and_disposal (line 243) | fn l0410_scope_creation_and_disposal(b: &mut Bencher) {
function sycamore_narrowing_down (line 274) | fn sycamore_narrowing_down(b: &mut Bencher) {
function sycamore_fanning_out (line 296) | fn sycamore_fanning_out(b: &mut Bencher) {
function sycamore_deep_creation (line 316) | fn sycamore_deep_creation(b: &mut Bencher) {
function sycamore_deep_update (line 336) | fn sycamore_deep_update(b: &mut Bencher) {
function sycamore_narrowing_update (line 357) | fn sycamore_narrowing_update(b: &mut Bencher) {
function sycamore_scope_creation_and_disposal (line 393) | fn sycamore_scope_creation_and_disposal(b: &mut Bencher) {
FILE: benchmarks/src/ssr.rs
function leptos_ssr_bench (line 4) | fn leptos_ssr_bench(b: &mut Bencher) {
function tachys_ssr_bench (line 39) | fn tachys_ssr_bench(b: &mut Bencher) {
function tera_ssr_bench (line 79) | fn tera_ssr_bench(b: &mut Bencher) {
function sycamore_ssr_bench (line 124) | fn sycamore_ssr_bench(b: &mut Bencher) {
function yew_ssr_bench (line 181) | fn yew_ssr_bench(b: &mut Bencher) {
FILE: benchmarks/src/todomvc/leptos.rs
type Todos (line 7) | pub struct Todos(pub Vec<Todo>);
method new (line 12) | pub fn new() -> Self {
method new_with_1000 (line 16) | pub fn new_with_1000() -> Self {
method is_empty (line 23) | pub fn is_empty(&self) -> bool {
method add (line 27) | pub fn add(&mut self, todo: Todo) {
method remove (line 31) | pub fn remove(&mut self, id: usize) {
method remaining (line 35) | pub fn remaining(&self) -> usize {
method completed (line 39) | pub fn completed(&self) -> usize {
method toggle_all (line 43) | pub fn toggle_all(&self) {
method clear_completed (line 60) | fn clear_completed(&mut self) {
constant STORAGE_KEY (line 9) | const STORAGE_KEY: &str = "todos-leptos";
type Todo (line 66) | pub struct Todo {
method new (line 75) | pub fn new(id: usize, title: String) -> Self {
method new_with_completed (line 79) | pub fn new_with_completed(
method toggle (line 95) | pub fn toggle(&self) {
constant ESCAPE_KEY (line 101) | const ESCAPE_KEY: u32 = 27;
constant ENTER_KEY (line 102) | const ENTER_KEY: u32 = 13;
function TodoMVC (line 105) | pub fn TodoMVC(todos: Todos) -> impl IntoView {
function Todo (line 247) | pub fn Todo(todo: Todo) -> impl IntoView {
method new (line 75) | pub fn new(id: usize, title: String) -> Self {
method new_with_completed (line 79) | pub fn new_with_completed(
method toggle (line 95) | pub fn toggle(&self) {
type Mode (line 298) | pub enum Mode {
method default (line 305) | fn default() -> Self {
function route (line 310) | pub fn route(hash: &str) -> Mode {
type TodoSerialized (line 319) | pub struct TodoSerialized {
method into_todo (line 326) | pub fn into_todo(self, ) -> Todo {
method from (line 332) | fn from(todo: &Todo) -> Self {
FILE: benchmarks/src/todomvc/mod.rs
function leptos_todomvc_ssr (line 10) | fn leptos_todomvc_ssr(b: &mut Bencher) {
function tachys_todomvc_ssr (line 25) | fn tachys_todomvc_ssr(b: &mut Bencher) {
function sycamore_todomvc_ssr (line 41) | fn sycamore_todomvc_ssr(b: &mut Bencher) {
function yew_todomvc_ssr (line 60) | fn yew_todomvc_ssr(b: &mut Bencher) {
function leptos_todomvc_ssr_with_1000 (line 74) | fn leptos_todomvc_ssr_with_1000(b: &mut Bencher) {
function tachys_todomvc_ssr_with_1000 (line 89) | fn tachys_todomvc_ssr_with_1000(b: &mut Bencher) {
function sycamore_todomvc_ssr_with_1000 (line 103) | fn sycamore_todomvc_ssr_with_1000(b: &mut Bencher) {
function yew_todomvc_ssr_with_1000 (line 122) | fn yew_todomvc_ssr_with_1000(b: &mut Bencher) {
function tera_todomvc_ssr (line 136) | fn tera_todomvc_ssr(b: &mut Bencher) {
FILE: benchmarks/src/todomvc/sycamore.rs
type Todo (line 8) | pub struct Todo {
type Filter (line 15) | pub enum Filter {
method url (line 28) | fn url(self) -> &'static str {
method get_filter_from_hash (line 36) | fn get_filter_from_hash() -> Self {
method default (line 22) | fn default() -> Self {
type AppState (line 48) | pub struct AppState {
method add_todo (line 54) | fn add_todo(&self, title: String, id: usize) {
method remove_todo (line 62) | fn remove_todo(&self, id: usize) {
method todos_left (line 66) | fn todos_left(&self) -> usize {
method toggle_complete_all (line 73) | fn toggle_complete_all(&self) {
method clear_completed (line 97) | fn clear_completed(&self) {
constant KEY (line 102) | const KEY: &str = "todos-sycamore";
function App (line 105) | pub fn App<G: Html>(cx: Scope) -> View<G> {
function AppWith1000 (line 127) | pub fn AppWith1000<G: Html>(cx: Scope) -> View<G> {
function Copyright (line 158) | pub fn Copyright<G: Html>(cx: Scope) -> View<G> {
function Header (line 175) | pub fn Header<G: Html>(cx: Scope) -> View<G> {
function Item (line 212) | pub fn Item<G: Html>(cx: Scope, todo: RcSignal<Todo>) -> View<G> {
function List (line 331) | pub fn List<G: Html>(cx: Scope) -> View<G> {
function TodoFilter (line 383) | pub fn TodoFilter<G: Html>(cx: Scope, filter: Filter) -> View<G> {
function Footer (line 402) | pub fn Footer<G: Html>(cx: Scope) -> View<G> {
FILE: benchmarks/src/todomvc/tachys.rs
type Todos (line 16) | pub struct Todos(pub Vec<Todo>);
method new (line 21) | pub fn new() -> Self {
method new_with_1000 (line 25) | pub fn new_with_1000() -> Self {
method is_empty (line 32) | pub fn is_empty(&self) -> bool {
method add (line 36) | pub fn add(&mut self, todo: Todo) {
method remove (line 40) | pub fn remove(&mut self, id: usize) {
method remaining (line 44) | pub fn remaining(&self) -> usize {
method completed (line 48) | pub fn completed(&self) -> usize {
method toggle_all (line 52) | pub fn toggle_all(&self) {
method clear_completed (line 69) | fn clear_completed(&mut self) {
constant STORAGE_KEY (line 18) | const STORAGE_KEY: &str = "todos-leptos";
type Todo (line 75) | pub struct Todo {
method new (line 84) | pub fn new(id: usize, title: String) -> Self {
method new_with_completed (line 88) | pub fn new_with_completed(
method toggle (line 104) | pub fn toggle(&self) {
constant ESCAPE_KEY (line 110) | const ESCAPE_KEY: u32 = 27;
constant ENTER_KEY (line 111) | const ENTER_KEY: u32 = 13;
function TodoMVC (line 113) | pub fn TodoMVC(todos: Todos) -> impl Render<Dom> + RenderHtml<Dom> {
function Todo (line 251) | pub fn Todo(todo: Todo) -> impl Render<Dom> + RenderHtml<Dom> {
method new (line 84) | pub fn new(id: usize, title: String) -> Self {
method new_with_completed (line 88) | pub fn new_with_completed(
method toggle (line 104) | pub fn toggle(&self) {
type Mode (line 292) | pub enum Mode {
method default (line 299) | fn default() -> Self {
function route (line 304) | pub fn route(hash: &str) -> Mode {
type TodoSerialized (line 313) | pub struct TodoSerialized {
method into_todo (line 320) | pub fn into_todo(self) -> Todo {
method from (line 326) | fn from(todo: &Todo) -> Self {
FILE: benchmarks/src/todomvc/tera.rs
function tera_todomvc_ssr (line 90) | fn tera_todomvc_ssr(b: &mut Bencher) {
function tera_todomvc_ssr_1000 (line 130) | fn tera_todomvc_ssr_1000(b: &mut Bencher) {
FILE: benchmarks/src/todomvc/yew.rs
constant KEY (line 8) | const KEY: &str = "yew.todomvc.self";
type Msg (line 10) | pub enum Msg {
type App (line 22) | pub struct App {
method view_filter (line 146) | fn view_filter(&self, filter: Filter, link: &Scope<Self>) -> Html {
method view_input (line 164) | fn view_input(&self, link: &Scope<Self>) -> Html {
method view_entry (line 191) | fn view_entry(&self, (idx, entry): (usize, &Entry), link: &Scope<Self>...
method view_entry_edit_input (line 216) | fn view_entry_edit_input(&self, (idx, entry): (usize, &Entry), link: &...
type Message (line 28) | type Message = Msg;
type Properties (line 29) | type Properties = ();
method create (line 31) | fn create(_ctx: &Context<Self>) -> Self {
method update (line 42) | fn update(&mut self, _ctx: &Context<Self>, msg: Self::Message) -> bool {
method view (line 96) | fn view(&self, ctx: &Context<Self>) -> Html {
type AppWith1000 (line 247) | pub struct AppWith1000 {
method view_filter (line 377) | fn view_filter(&self, filter: Filter, link: &Scope<Self>) -> Html {
method view_input (line 395) | fn view_input(&self, link: &Scope<Self>) -> Html {
method view_entry (line 422) | fn view_entry(&self, (idx, entry): (usize, &Entry), link: &Scope<Self>...
method view_entry_edit_input (line 447) | fn view_entry_edit_input(&self, (idx, entry): (usize, &Entry), link: &...
type Message (line 253) | type Message = Msg;
type Properties (line 254) | type Properties = ();
method create (line 256) | fn create(_ctx: &Context<Self>) -> Self {
method update (line 273) | fn update(&mut self, _ctx: &Context<Self>, msg: Self::Message) -> bool {
method view (line 327) | fn view(&self, ctx: &Context<Self>) -> Html {
type State (line 482) | pub struct State {
method total (line 489) | pub fn total(&self) -> usize {
method total_completed (line 493) | pub fn total_completed(&self) -> usize {
method is_all_completed (line 500) | pub fn is_all_completed(&self) -> bool {
method clear_completed (line 514) | pub fn clear_completed(&mut self) {
method toggle (line 523) | pub fn toggle(&mut self, idx: usize) {
method toggle_all (line 534) | pub fn toggle_all(&mut self, value: bool) {
method toggle_edit (line 542) | pub fn toggle_edit(&mut self, idx: usize) {
method clear_all_edit (line 553) | pub fn clear_all_edit(&mut self) {
method complete_edit (line 559) | pub fn complete_edit(&mut self, idx: usize, val: String) {
method remove (line 575) | pub fn remove(&mut self, idx: usize) {
type Entry (line 591) | pub struct Entry {
type Filter (line 598) | pub enum Filter {
method fits (line 604) | pub fn fits(&self, entry: &Entry) -> bool {
method as_href (line 612) | pub fn as_href(&self) -> &'static str {
FILE: const_str_slice_concat/src/lib.rs
constant MAX_TEMPLATE_SIZE (line 7) | pub(crate) const MAX_TEMPLATE_SIZE: usize = 4096;
function str_from_buffer (line 10) | pub const fn str_from_buffer(buf: &[u8; MAX_TEMPLATE_SIZE]) -> &str {
function const_concat (line 22) | pub const fn const_concat(
function const_concat_with_prefix (line 48) | pub const fn const_concat_with_prefix(
function const_concat_with_separator (line 106) | pub const fn const_concat_with_separator(
FILE: either_of/src/lib.rs
function swap (line 472) | pub fn swap(self) -> Either<B, A> {
function from (line 481) | fn from(value: Result<A, B>) -> Self {
type EitherOr (line 489) | pub trait EitherOr {
method either_or (line 492) | fn either_or<FA, A, FB, B>(self, a: FA, b: FB) -> Either<A, B>
type Left (line 499) | type Left = ();
type Right (line 500) | type Right = ();
method either_or (line 502) | fn either_or<FA, A, FB, B>(self, a: FA, b: FB) -> Either<A, B>
type Left (line 516) | type Left = T;
type Right (line 517) | type Right = ();
method either_or (line 519) | fn either_or<FA, A, FB, B>(self, a: FA, b: FB) -> Either<A, B>
type Left (line 532) | type Left = T;
type Right (line 533) | type Right = E;
method either_or (line 535) | fn either_or<FA, A, FB, B>(self, a: FA, b: FB) -> Either<A, B>
type Left (line 548) | type Left = A;
type Right (line 549) | type Right = B;
method either_or (line 552) | fn either_or<FA, A1, FB, B1>(self, a: FA, b: FB) -> Either<A1, B1>
function test_either_or (line 562) | fn test_either_or() {
function either_macro (line 981) | fn either_macro() {
function unwrap_wrong_either (line 1238) | fn unwrap_wrong_either() {
FILE: examples/action-form-error-handling/src/app.rs
function App (line 8) | pub fn App() -> impl IntoView {
function do_something (line 22) | async fn do_something(
function HomePage (line 36) | fn HomePage() -> impl IntoView {
function NotFound (line 65) | fn NotFound() -> impl IntoView {
FILE: examples/action-form-error-handling/src/lib.rs
function hydrate (line 5) | pub fn hydrate() {
FILE: examples/action-form-error-handling/src/main.rs
function main (line 3) | async fn main() -> std::io::Result<()> {
function main (line 56) | pub fn main() {
FILE: examples/axum_js_ssr/src/api.rs
function fetch_code (line 4) | pub async fn fetch_code() -> Result<String, ServerFnError> {
FILE: examples/axum_js_ssr/src/app.rs
function shell (line 12) | pub fn shell(options: LeptosOptions) -> impl IntoView {
function App (line 31) | pub fn App() -> impl IntoView {
function HomePage (line 102) | fn HomePage() -> impl IntoView {
type CodeDemoHook (line 130) | struct CodeDemoHook {
function CodeDemo (line 135) | fn CodeDemo() -> impl IntoView {
function Naive (line 177) | fn Naive() -> impl IntoView {
function NaiveEvent (line 269) | fn NaiveEvent(
function CustomEvent (line 395) | fn CustomEvent() -> impl IntoView {
function CodeDemoSignalEffect (line 488) | fn CodeDemoSignalEffect() -> impl IntoView {
type WasmDemo (line 600) | enum WasmDemo {
function CodeDemoWasm (line 607) | fn CodeDemoWasm(mode: WasmDemo) -> impl IntoView {
function WasmBindgenNaive (line 734) | fn WasmBindgenNaive() -> impl IntoView {
function WasmBindgenJSHookReadyEvent (line 777) | fn WasmBindgenJSHookReadyEvent() -> impl IntoView {
function WasmBindgenEffect (line 865) | fn WasmBindgenEffect() -> impl IntoView {
type InnerEffect (line 911) | struct InnerEffect;
function CodeInner (line 914) | fn CodeInner(code: String, lang: String) -> impl IntoView {
function CodeDemoWasmInner (line 960) | fn CodeDemoWasmInner() -> impl IntoView {
function WasmBindgenDirect (line 1001) | fn WasmBindgenDirect() -> impl IntoView {
function WasmBindgenDirectFixed (line 1059) | fn WasmBindgenDirectFixed() -> impl IntoView {
FILE: examples/axum_js_ssr/src/consts.rs
constant CH03_05A (line 3) | pub const CH03_05A: &str = r#"fn main() {
constant CH05_02A (line 24) | pub const CH05_02A: &str = r#"fn main() {
constant LEPTOS_HYDRATED (line 39) | pub const LEPTOS_HYDRATED: &str = "_leptos_hydrated";
FILE: examples/axum_js_ssr/src/hljs.rs
function highlight_lang (line 17) | fn highlight_lang(
function highlight_all (line 23) | pub fn highlight_all();
function highlight (line 30) | pub fn highlight(code: String, lang: String) -> Option<String> {
function highlight_all (line 47) | pub fn highlight_all() {}
FILE: examples/axum_js_ssr/src/lib.rs
function hydrate (line 8) | pub fn hydrate() {
FILE: examples/axum_js_ssr/src/main.rs
function main (line 14) | async fn main() {
function main (line 148) | pub fn main() {
FILE: examples/counter/src/lib.rs
function SimpleCounter (line 7) | pub fn SimpleCounter(
FILE: examples/counter/src/main.rs
function main (line 4) | pub fn main() {
FILE: examples/counter/tests/web.rs
function clear (line 11) | async fn clear() {
function inc (line 81) | async fn inc() {
FILE: examples/counter_isomorphic/src/counters.rs
function get_server_count (line 23) | pub async fn get_server_count() -> Result<i32, ServerFnError> {
function adjust_server_count (line 31) | pub async fn adjust_server_count(
function clear_server_count (line 46) | pub async fn clear_server_count() -> Result<i32, ServerFnError> {
function Counters (line 54) | pub fn Counters() -> impl IntoView {
function Counter (line 93) | pub fn Counter() -> impl IntoView {
function FormCounter (line 130) | pub fn FormCounter() -> impl IntoView {
function MultiuserCounter (line 183) | pub fn MultiuserCounter() -> impl IntoView {
FILE: examples/counter_isomorphic/src/lib.rs
function hydrate (line 5) | pub fn hydrate() {
FILE: examples/counter_isomorphic/src/main.rs
function counter_events (line 9) | async fn counter_events() -> impl Responder {
function main (line 28) | async fn main() -> std::io::Result<()> {
FILE: examples/counter_url_query/src/lib.rs
function SimpleQueryCounter (line 8) | pub fn SimpleQueryCounter() -> impl IntoView {
FILE: examples/counter_url_query/src/main.rs
function main (line 5) | pub fn main() {
FILE: examples/counter_without_macros/src/lib.rs
function counter (line 9) | pub fn counter(initial_value: i32, step: u32) -> impl IntoView {
type Count (line 40) | pub struct Count {
method new (line 46) | pub fn new(value: i32, step: u32) -> Self {
method value (line 53) | pub fn value(&self) -> i32 {
method increase (line 58) | pub fn increase(&mut self) {
method decrease (line 62) | pub fn decrease(&mut self) {
method clear (line 66) | pub fn clear(&mut self) {
FILE: examples/counter_without_macros/src/main.rs
function main (line 4) | pub fn main() {
FILE: examples/counter_without_macros/tests/business.rs
function should_increase_count (line 14) | fn should_increase_count(#[case] initial_value: i32, #[case] step: u32) {
function should_decrease_count (line 29) | fn should_decrease_count(#[case] initial_value: i32, #[case] step: u32) {
function should_clear_count (line 44) | fn should_clear_count(#[case] initial_value: i32, #[case] step: u32) {
FILE: examples/counter_without_macros/tests/web.rs
function should_increment_counter (line 13) | async fn should_increment_counter() {
function should_decrement_counter (line 26) | async fn should_decrement_counter() {
function should_clear_counter (line 38) | async fn should_clear_counter() {
function open_counter (line 51) | fn open_counter() {
function remove_existing_counter (line 56) | fn remove_existing_counter() {
function click_clear (line 62) | fn click_clear() {
function click_decrement (line 66) | fn click_decrement() {
function click_increment (line 70) | fn click_increment() {
function click_text (line 74) | fn click_text(text: &str) {
function see_text (line 78) | fn see_text() -> Option<String> {
function find_by_text (line 82) | fn find_by_text(text: &str) -> HtmlElement {
FILE: examples/counters/e2e/tests/fixtures/counters_page.ts
class CountersPage (line 3) | class CountersPage {
method constructor (line 17) | constructor(page: Page) {
method goto (line 49) | async goto() {
method addCounter (line 53) | async addCounter() {
method addOneThousandCounters (line 60) | async addOneThousandCounters() {
method decrementCount (line 64) | async decrementCount(index: number = 0) {
method incrementCount (line 71) | async incrementCount(index: number = 0) {
method clearCounters (line 78) | async clearCounters() {
method enterCount (line 85) | async enterCount(count: string, index: number = 0) {
method removeCounter (line 92) | async removeCounter(index: number = 0) {
FILE: examples/counters/src/lib.rs
constant MANY_COUNTERS (line 3) | const MANY_COUNTERS: usize = 1000;
type CounterHolder (line 5) | type CounterHolder = Vec<(usize, ArcRwSignal<i32>)>;
type CounterUpdater (line 8) | struct CounterUpdater {
function Counters (line 13) | pub fn Counters() -> impl IntoView {
function Counter (line 71) | fn Counter(id: usize, value: ArcRwSignal<i32>) -> impl IntoView {
FILE: examples/counters/src/main.rs
function main (line 3) | fn main() {
FILE: examples/counters/tests/web.rs
function inc (line 12) | async fn inc() {
FILE: examples/directives/src/lib.rs
function highlight (line 5) | pub fn highlight(el: Element) {
function copy_to_clipboard (line 21) | pub fn copy_to_clipboard(el: Element, content: &str) {
type Amount (line 37) | pub struct Amount(usize);
method from (line 40) | fn from(value: usize) -> Self {
method from (line 47) | fn from(_: ()) -> Self {
function add_dot (line 52) | pub fn add_dot(el: Element, amount: Amount) {
function SomeComponent (line 67) | pub fn SomeComponent() -> impl IntoView {
function App (line 76) | pub fn App() -> impl IntoView {
FILE: examples/directives/src/main.rs
function main (line 4) | fn main() {
FILE: examples/directives/tests/web.rs
function test_directives (line 11) | async fn test_directives() {
FILE: examples/error_boundary/e2e/tests/fixtures/home_page.ts
class HomePage (line 3) | class HomePage {
method constructor (line 12) | constructor(page: Page) {
method goto (line 24) | async goto() {
method enterNumber (line 28) | async enterNumber(count: string, index: number = 0) {
method clickUpArrow (line 35) | async clickUpArrow() {
method clickDownArrow (line 42) | async clickDownArrow() {
method clearInput (line 49) | async clearInput() {
FILE: examples/error_boundary/src/lib.rs
function App (line 4) | pub fn App() -> impl IntoView {
FILE: examples/error_boundary/src/main.rs
function main (line 4) | pub fn main() {
FILE: examples/errors_axum/src/error_template.rs
function ErrorTemplate (line 9) | pub fn ErrorTemplate(#[prop(into)] errors: Signal<Errors>) -> impl IntoV...
FILE: examples/errors_axum/src/errors.rs
type AppError (line 5) | pub enum AppError {
method status_code (line 13) | pub fn status_code(&self) -> StatusCode {
FILE: examples/errors_axum/src/landing.rs
function cause_internal_server_error (line 10) | pub async fn cause_internal_server_error() -> Result<(), ServerFnError> {
function shell (line 19) | pub fn shell(options: LeptosOptions) -> impl IntoView {
function App (line 38) | pub fn App() -> impl IntoView {
function ExampleErrors (line 64) | pub fn ExampleErrors() -> impl IntoView {
function ReturnsError (line 93) | pub fn ReturnsError() -> impl IntoView {
FILE: examples/errors_axum/src/lib.rs
function hydrate (line 7) | pub fn hydrate() {
FILE: examples/errors_axum/src/main.rs
function custom_handler (line 18) | pub async fn custom_handler(
function main (line 35) | async fn main() {
function main (line 67) | pub fn main() {
FILE: examples/fetch/src/lib.rs
type Cat (line 6) | pub struct Cat {
type CatError (line 11) | pub enum CatError {
type CatCount (line 16) | type CatCount = usize;
function fetch_cats (line 18) | async fn fetch_cats(count: CatCount) -> Result<Vec<String>, Error> {
function fetch_example (line 41) | pub fn fetch_example() -> impl IntoView {
FILE: examples/fetch/src/main.rs
function main (line 4) | pub fn main() {
FILE: examples/hackernews/src/api.rs
function story (line 3) | pub fn story(path: &str) -> String {
function user (line 7) | pub fn user(path: &str) -> String {
function fetch_api (line 12) | pub fn fetch_api<T>(
function fetch_api (line 46) | pub async fn fetch_api<T>(path: &str) -> Option<T>
type Story (line 60) | pub struct Story {
type Comment (line 78) | pub struct Comment {
type User (line 89) | pub struct User {
FILE: examples/hackernews/src/lib.rs
function App (line 13) | pub fn App() -> impl IntoView {
function hydrate (line 40) | pub fn hydrate() {
FILE: examples/hackernews/src/main.rs
function css (line 9) | pub async fn css() -> impl Responder {
function favicon (line 13) | pub async fn favicon() -> impl Responder {
function main (line 20) | async fn main() -> std::io::Result<()> {
function main (line 69) | fn main() {
FILE: examples/hackernews/src/routes/nav.rs
function Nav (line 5) | pub fn Nav() -> impl IntoView {
FILE: examples/hackernews/src/routes/stories.rs
function category (line 8) | fn category(from: &str) -> &'static str {
function Stories (line 19) | pub fn Stories() -> impl IntoView {
function Story (line 120) | fn Story(story: api::Story) -> impl IntoView {
FILE: examples/hackernews/src/routes/story.rs
function Story (line 7) | pub fn Story() -> impl IntoView {
function Comment (line 69) | pub fn Comment(comment: api::Comment) -> impl IntoView {
function pluralize (line 137) | fn pluralize(n: usize) -> &'static str {
FILE: examples/hackernews/src/routes/users.rs
function User (line 6) | pub fn User() -> impl IntoView {
FILE: examples/hackernews_axum/src/api.rs
function story (line 4) | pub fn story(path: &str) -> String {
function user (line 8) | pub fn user(path: &str) -> String {
function fetch_api (line 13) | pub fn fetch_api<T>(
function fetch_api (line 47) | pub async fn fetch_api<T>(path: &str) -> Option<T>
type Story (line 61) | pub struct Story {
type Comment (line 79) | pub struct Comment {
type User (line 90) | pub struct User {
FILE: examples/hackernews_axum/src/error_template.rs
function error_template (line 5) | pub fn error_template(errors: Option<RwSignal<Errors>>) -> View {
FILE: examples/hackernews_axum/src/lib.rs
function shell (line 12) | pub fn shell(options: LeptosOptions) -> impl IntoView {
function App (line 31) | pub fn App() -> impl IntoView {
function hydrate (line 58) | pub fn hydrate() {
FILE: examples/hackernews_axum/src/main.rs
function main (line 3) | async fn main() {
function main (line 43) | pub fn main() {
FILE: examples/hackernews_axum/src/routes/nav.rs
function Nav (line 5) | pub fn Nav() -> impl IntoView {
FILE: examples/hackernews_axum/src/routes/stories.rs
function category (line 8) | fn category(from: &str) -> &'static str {
function Stories (line 19) | pub fn Stories() -> impl IntoView {
function Story (line 111) | fn Story(story: api::Story) -> impl IntoView {
FILE: examples/hackernews_axum/src/routes/story.rs
type StoryRoute (line 9) | pub struct StoryRoute {
method data (line 15) | fn data() -> Self {
method view (line 33) | fn view(this: Self) -> AnyView {
function Comment (line 85) | pub fn Comment(comment: api::Comment) -> impl IntoView {
function pluralize (line 131) | fn pluralize(n: usize) -> &'static str {
FILE: examples/hackernews_axum/src/routes/users.rs
type UserRoute (line 6) | pub struct UserRoute {
method data (line 12) | fn data() -> Self {
method view (line 27) | fn view(this: Self) -> AnyView {
FILE: examples/hackernews_islands_axum/src/api.rs
function story (line 6) | pub fn story(path: &str) -> String {
function user (line 11) | pub fn user(path: &str) -> String {
function fetch_api (line 16) | pub async fn fetch_api<T>(path: &str) -> Option<T>
type Story (line 31) | pub struct Story {
type Comment (line 49) | pub struct Comment {
type User (line 60) | pub struct User {
FILE: examples/hackernews_islands_axum/src/fallback.rs
constant DEV_MODE (line 10) | const DEV_MODE: bool = false;
constant DEV_MODE (line 13) | const DEV_MODE: bool = true;
type Assets (line 17) | struct Assets;
function file_and_error_handler (line 19) | pub async fn file_and_error_handler(
function get_static_file (line 43) | async fn get_static_file(
FILE: examples/hackernews_islands_axum/src/lib.rs
function shell (line 13) | pub fn shell(options: LeptosOptions) -> impl IntoView {
function App (line 32) | pub fn App() -> impl IntoView {
function hydrate (line 54) | pub fn hydrate() {
FILE: examples/hackernews_islands_axum/src/main.rs
function main (line 3) | async fn main() {
function main (line 53) | pub fn main() {
FILE: examples/hackernews_islands_axum/src/routes/nav.rs
function Nav (line 5) | pub fn Nav() -> impl IntoView {
FILE: examples/hackernews_islands_axum/src/routes/stories.rs
function category (line 8) | fn category(from: &str) -> String {
function fetch_stories (line 20) | pub async fn fetch_stories(
function Stories (line 31) | pub fn Stories() -> impl IntoView {
function Story (line 122) | fn Story(story: api::Story) -> impl IntoView {
FILE: examples/hackernews_islands_axum/src/routes/story.rs
function fetch_story (line 7) | pub async fn fetch_story(
function Story (line 14) | pub fn Story() -> impl IntoView {
function Comment (line 76) | pub fn Comment(comment: api::Comment) -> impl IntoView {
function Toggle (line 98) | pub fn Toggle(children: Children) -> impl IntoView {
FILE: examples/hackernews_islands_axum/src/routes/users.rs
function fetch_user (line 6) | pub async fn fetch_user(
function User (line 13) | pub fn User() -> impl IntoView {
FILE: examples/hackernews_js_fetch/src/api.rs
function story (line 4) | pub fn story(path: &str) -> String {
function user (line 8) | pub fn user(path: &str) -> String {
function fetch_api (line 13) | pub fn fetch_api<T>(
function fetch_api (line 47) | pub async fn fetch_api<T>(path: &str) -> Option<T>
type Story (line 61) | pub struct Story {
type Comment (line 79) | pub struct Comment {
type User (line 90) | pub struct User {
FILE: examples/hackernews_js_fetch/src/lib.rs
function shell (line 12) | pub fn shell(options: LeptosOptions) -> impl IntoView {
function App (line 31) | pub fn App() -> impl IntoView {
function hydrate (line 58) | pub fn hydrate() {
type Handler (line 73) | pub struct Handler(axum_js_fetch::App);
method new (line 77) | pub async fn new() -> Self {
method serve (line 101) | pub async fn serve(&self, req: web_sys::Request) -> web_sys::Response {
FILE: examples/hackernews_js_fetch/src/routes/nav.rs
function Nav (line 5) | pub fn Nav() -> impl IntoView {
FILE: examples/hackernews_js_fetch/src/routes/stories.rs
function category (line 9) | fn category(from: &str) -> &'static str {
function Stories (line 20) | pub fn Stories() -> impl IntoView {
function Story (line 115) | fn Story(story: api::Story) -> impl IntoView {
FILE: examples/hackernews_js_fetch/src/routes/story.rs
function Story (line 8) | pub fn Story() -> impl IntoView {
function Comment (line 72) | pub fn Comment(comment: api::Comment) -> impl IntoView {
function pluralize (line 135) | fn pluralize(n: usize) -> &'static str {
FILE: examples/hackernews_js_fetch/src/routes/users.rs
function User (line 7) | pub fn User() -> impl IntoView {
FILE: examples/islands/src/app.rs
function shell (line 3) | pub fn shell(options: LeptosOptions) -> impl IntoView {
function App (line 23) | pub fn App() -> impl IntoView {
function OuterIsland (line 39) | pub fn OuterIsland(children: Children) -> impl IntoView {
function InnerIsland (line 53) | pub fn InnerIsland() -> impl IntoView {
FILE: examples/islands/src/lib.rs
function hydrate (line 5) | pub fn hydrate() {
FILE: examples/islands/src/main.rs
function main (line 7) | async fn main() {
FILE: examples/islands_router/src/app.rs
function shell (line 12) | pub fn shell(options: LeptosOptions) -> impl IntoView {
function App (line 32) | pub fn App() -> impl IntoView {
function search (line 54) | pub async fn search(query: String) -> Result<Vec<User>, ServerFnError> {
function delete_user (line 69) | pub async fn delete_user(id: u32) -> Result<(), ServerFnError> {
type User (line 79) | pub struct User {
function Home (line 87) | pub fn Home() -> impl IntoView {
function Details (line 151) | pub fn Details() -> impl IntoView {
function About (line 193) | pub fn About() -> impl IntoView {
function Counter (line 205) | pub fn Counter() -> impl IntoView {
FILE: examples/islands_router/src/lib.rs
function hydrate (line 5) | pub fn hydrate() {
FILE: examples/islands_router/src/main.rs
function main (line 7) | async fn main() {
FILE: examples/js-framework-benchmark/src/lib.rs
type RowData (line 43) | struct RowData {
function build_data (line 50) | fn build_data(count: usize) -> Vec<RowData> {
function Button (line 82) | fn Button(
function App (line 98) | pub fn App() -> impl IntoView {
FILE: examples/js-framework-benchmark/src/main.rs
function main (line 6) | pub fn main() {
FILE: examples/js-framework-benchmark/tests/web.rs
function add_item (line 9) | async fn add_item() {
FILE: examples/lazy_routes/e2e/tests/app_suite.rs
function main (line 9) | async fn main() -> Result<()> {
FILE: examples/lazy_routes/e2e/tests/fixtures/action.rs
function goto_path (line 6) | pub async fn goto_path(client: &Client, path: &str) -> Result<()> {
function click_link (line 13) | pub async fn click_link(client: &Client, text: &str) -> Result<()> {
function click_button (line 19) | pub async fn click_button(client: &Client, id: &str) -> Result<()> {
FILE: examples/lazy_routes/e2e/tests/fixtures/check.rs
function page_name_is (line 6) | pub async fn page_name_is(client: &Client, expected_text: &str) -> Resul...
function result_is (line 12) | pub async fn result_is(client: &Client, expected_text: &str) -> Result<(...
function navigating_appears (line 18) | pub async fn navigating_appears(client: &Client) -> Result<()> {
function element_exists (line 24) | pub async fn element_exists(client: &Client, id: &str) -> Result<()> {
FILE: examples/lazy_routes/e2e/tests/fixtures/find.rs
function text_at_id (line 4) | pub async fn text_at_id(client: &Client, id: &str) -> Result<String> {
function link_with_text (line 12) | pub async fn link_with_text(client: &Client, text: &str) -> Result<Eleme...
function element_by_id (line 21) | pub async fn element_by_id(client: &Client, id: &str) -> Result<Element> {
FILE: examples/lazy_routes/e2e/tests/fixtures/world/action_steps.rs
function i_open_the_app (line 7) | async fn i_open_the_app(world: &mut AppWorld) -> Result<()> {
function i_open_the_app_at (line 15) | async fn i_open_the_app_at(world: &mut AppWorld, url: String) -> Result<...
function i_select_the_link (line 23) | async fn i_select_the_link(world: &mut AppWorld, text: String) -> Result...
function i_click_the_button (line 31) | async fn i_click_the_button(world: &mut AppWorld, id: String) -> Result<...
function i_select_the_following_links (line 39) | async fn i_select_the_following_links(
function i_wait_for_a_second (line 55) | async fn i_wait_for_a_second(world: &mut AppWorld) -> Result<()> {
function i_refresh_the_browser (line 63) | async fn i_refresh_the_browser(world: &mut AppWorld) -> Result<()> {
FILE: examples/lazy_routes/e2e/tests/fixtures/world/check_steps.rs
function i_see_the_nav (line 6) | async fn i_see_the_nav(world: &mut AppWorld) -> Result<()> {
function i_see_the_page_is (line 13) | async fn i_see_the_page_is(world: &mut AppWorld, text: String) -> Result...
function i_see_the_result_is (line 20) | async fn i_see_the_result_is(world: &mut AppWorld, text: String) -> Resu...
function i_see_the_navbar (line 27) | async fn i_see_the_navbar(world: &mut AppWorld) -> Result<()> {
FILE: examples/lazy_routes/e2e/tests/fixtures/world/mod.rs
constant HOST (line 10) | pub const HOST: &str = "http://127.0.0.1:3000";
type AppWorld (line 14) | pub struct AppWorld {
method new (line 19) | async fn new() -> Result<Self, anyhow::Error> {
function build_client (line 28) | async fn build_client() -> Result<Client, NewSessionError> {
FILE: examples/lazy_routes/src/app.rs
function shell (line 8) | pub fn shell(options: LeptosOptions) -> impl IntoView {
function App (line 26) | pub fn App() -> impl IntoView {
function ViewA (line 60) | pub fn ViewA() -> impl IntoView {
type Comment (line 85) | pub struct Comment {
function deserialize_comments (line 95) | fn deserialize_comments(data: &str) -> Vec<Comment> {
function ViewB (line 100) | pub fn ViewB() -> impl IntoView {
type Album (line 157) | pub struct Album {
type ViewC (line 166) | pub struct ViewC {
method data (line 181) | fn data() -> Self {
method view (line 212) | fn view(this: Self) -> AnyView {
function first_value (line 244) | pub fn first_value() -> String {
function second_value (line 259) | pub fn second_value() -> String {
type ViewD (line 273) | struct ViewD {
method data (line 279) | fn data() -> Self {
method view (line 285) | fn view(this: Self) -> AnyView {
function d_data (line 312) | async fn d_data() -> Result<Vec<i32>, ServerFnError> {
type ViewE (line 317) | struct ViewE {
method data (line 323) | fn data() -> Self {
method view (line 329) | fn view(this: Self) -> AnyView {
function e_data (line 352) | async fn e_data() -> Result<Vec<String>, ServerFnError> {
FILE: examples/lazy_routes/src/lib.rs
function hydrate (line 5) | pub fn hydrate() {
FILE: examples/lazy_routes/src/main.rs
function main (line 3) | async fn main() {
function main (line 33) | pub fn main() {
FILE: examples/parent_child/src/lib.rs
type SmallcapsContext (line 14) | struct SmallcapsContext(WriteSignal<bool>);
function App (line 17) | pub fn App() -> impl IntoView {
function ButtonA (line 60) | pub fn ButtonA(
function ButtonB (line 69) | pub fn ButtonB(
function ButtonC (line 79) | pub fn ButtonC() -> impl IntoView {
function ButtonD (line 86) | pub fn ButtonD() -> impl IntoView {
FILE: examples/parent_child/src/main.rs
function main (line 4) | pub fn main() {
FILE: examples/portal/src/lib.rs
function App (line 4) | pub fn App() -> impl IntoView {
FILE: examples/portal/src/main.rs
function main (line 5) | fn main() {
FILE: examples/portal/tests/web.rs
function minify (line 10) | fn minify(html: &str) -> String {
function portal (line 64) | async fn portal() {
function test_minify (line 139) | fn test_minify() {
function test_preserve_whitespace_in_tags (line 155) | fn test_preserve_whitespace_in_tags() {
FILE: examples/regression/e2e/tests/app_suite.rs
function main (line 9) | async fn main() -> Result<()> {
FILE: examples/regression/e2e/tests/fixtures/action.rs
function goto_path (line 6) | pub async fn goto_path(client: &Client, path: &str) -> Result<()> {
function click_link (line 13) | pub async fn click_link(client: &Client, text: &str) -> Result<()> {
function click_button (line 19) | pub async fn click_button(client: &Client, id: &str) -> Result<()> {
FILE: examples/regression/e2e/tests/fixtures/check.rs
function result_text_is (line 6) | pub async fn result_text_is(
function element_text_is (line 13) | pub async fn element_text_is(
function element_exists (line 23) | pub async fn element_exists(client: &Client, id: &str) -> Result<()> {
function select_option_is_selected (line 30) | pub async fn select_option_is_selected(
function element_value_is (line 42) | pub async fn element_value_is(
function path_is (line 55) | pub async fn path_is(client: &Client, expected_path: &str) -> Result<()> {
FILE: examples/regression/e2e/tests/fixtures/find.rs
function text_at_id (line 4) | pub async fn text_at_id(client: &Client, id: &str) -> Result<String> {
function link_with_text (line 12) | pub async fn link_with_text(client: &Client, text: &str) -> Result<Eleme...
function element_by_id (line 21) | pub async fn element_by_id(client: &Client, id: &str) -> Result<Element> {
FILE: examples/regression/e2e/tests/fixtures/world/action_steps.rs
function i_open_the_app (line 7) | async fn i_open_the_app(world: &mut AppWorld) -> Result<()> {
function i_select_the_link (line 16) | async fn i_select_the_link(world: &mut AppWorld, text: String) -> Result...
function i_click_the_button (line 24) | async fn i_click_the_button(world: &mut AppWorld, id: String) -> Result<...
function i_select_the_following_links (line 33) | async fn i_select_the_following_links(
function i_refresh_the_browser (line 50) | async fn i_refresh_the_browser(world: &mut AppWorld) -> Result<()> {
function i_go_back (line 59) | async fn i_go_back(world: &mut AppWorld) -> Result<()> {
function i_wait_ms (line 67) | async fn i_wait_ms(_world: &mut AppWorld, ms: u64) -> Result<()> {
FILE: examples/regression/e2e/tests/fixtures/world/check_steps.rs
function i_see_the_result_is_empty (line 6) | async fn i_see_the_result_is_empty(world: &mut AppWorld) -> Result<()> {
function i_see_the_result_is_the_string (line 13) | async fn i_see_the_result_is_the_string(
function i_see_element_has_text (line 23) | async fn i_see_element_has_text(
function i_see_the_navbar (line 34) | async fn i_see_the_navbar(world: &mut AppWorld) -> Result<()> {
function i_see_the_select (line 41) | async fn i_see_the_select(world: &mut AppWorld, id: String) -> Result<()> {
function i_see_the_value (line 48) | async fn i_see_the_value(
function i_see_the_path (line 59) | async fn i_see_the_path(world: &mut AppWorld, path: String) -> Result<()> {
FILE: examples/regression/e2e/tests/fixtures/world/mod.rs
constant HOST (line 10) | pub const HOST: &str = "http://127.0.0.1:3000";
type AppWorld (line 14) | pub struct AppWorld {
method new (line 19) | async fn new() -> Result<Self, anyhow::Error> {
function build_client (line 28) | async fn build_client() -> Result<Client, NewSessionError> {
FILE: examples/regression/src/app.rs
function shell (line 13) | pub fn shell(options: LeptosOptions) -> impl IntoView {
function App (line 32) | pub fn App() -> impl IntoView {
function server_call (line 59) | async fn server_call() -> Result<(), ServerFnError> {
function HomePage (line 65) | fn HomePage() -> impl IntoView {
FILE: examples/regression/src/issue_4005.rs
function Routes4005 (line 8) | pub fn Routes4005() -> impl MatchNestedRoutes + Clone {
function Issue4005 (line 16) | fn Issue4005() -> impl IntoView {
FILE: examples/regression/src/issue_4088.rs
function Routes4088 (line 10) | pub fn Routes4088() -> impl MatchNestedRoutes + Clone {
type UserInfo (line 23) | pub struct UserInfo {
function get_user_info (line 28) | pub async fn get_user_info() -> Result<Option<UserInfo>, ServerFnError> {
function LoggedIn (line 33) | pub fn LoggedIn() -> impl IntoView {
function LoggedInContent (line 62) | pub fn LoggedInContent(user_info: UserInfo) -> impl IntoView {
function AssignmentsSelector (line 76) | fn AssignmentsSelector() -> impl IntoView {
function AssignmentsForTeam (line 92) | fn AssignmentsForTeam() -> impl IntoView {
function Assignment (line 113) | fn Assignment(name: String) -> impl IntoView {
FILE: examples/regression/src/issue_4217.rs
function Routes4217 (line 8) | pub fn Routes4217() -> impl MatchNestedRoutes + Clone {
function Issue4217 (line 16) | fn Issue4217() -> impl IntoView {
FILE: examples/regression/src/issue_4285.rs
function Routes4285 (line 9) | pub fn Routes4285() -> impl MatchNestedRoutes + Clone {
type Issue4285 (line 16) | struct Issue4285 {
method data (line 21) | fn data() -> Self {
method view (line 27) | async fn view(this: Self) -> AnyView {
function slow_call (line 46) | async fn slow_call() -> Result<i32, ServerFnError> {
FILE: examples/regression/src/issue_4296.rs
function Routes4296 (line 9) | pub fn Routes4296() -> impl MatchNestedRoutes + Clone {
type Issue4296 (line 16) | struct Issue4296 {
method data (line 21) | fn data() -> Self {
method view (line 27) | async fn view(this: Self) -> AnyView {
FILE: examples/regression/src/issue_4324.rs
function Routes4324 (line 8) | pub fn Routes4324() -> impl MatchNestedRoutes + Clone {
function Issue4324 (line 16) | pub fn Issue4324() -> impl IntoView {
FILE: examples/regression/src/issue_4492.rs
function Routes4492 (line 8) | pub fn Routes4492() -> impl MatchNestedRoutes + Clone {
function Issue4492 (line 16) | fn Issue4492() -> impl IntoView {
function ScenarioA (line 39) | fn ScenarioA() -> impl IntoView {
function ScenarioB (line 58) | fn ScenarioB() -> impl IntoView {
function ScenarioC (line 81) | fn ScenarioC() -> impl IntoView {
function sleep (line 111) | async fn sleep(ms: u64) -> Result<(), ServerFnError> {
FILE: examples/regression/src/lib.rs
function hydrate (line 14) | pub fn hydrate() {
FILE: examples/regression/src/main.rs
function main (line 3) | async fn main() {
function main (line 38) | pub fn main() {
FILE: examples/regression/src/pr_4015.rs
function Routes4015 (line 9) | pub fn Routes4015() -> impl leptos_router::MatchNestedRoutes + Clone {
function Child (line 23) | fn Child() -> impl IntoView {
FILE: examples/regression/src/pr_4091.rs
type Expectations (line 12) | struct Expectations(Vec<&'static str>);
function Routes4091 (line 15) | pub fn Routes4091() -> impl leptos_router::MatchNestedRoutes + Clone {
function Container (line 26) | fn Container() -> impl IntoView {
function Root (line 48) | fn Root() -> impl IntoView {
function Test1 (line 55) | fn Test1() -> impl IntoView {
FILE: examples/router/src/api.rs
type ContactSummary (line 10) | pub struct ContactSummary {
type Contact (line 17) | pub struct Contact {
function get_contacts (line 30) | pub async fn get_contacts(_search: String) -> Vec<ContactSummary> {
function get_contact (line 52) | pub async fn get_contact(id: Option<usize>) -> Option<Contact> {
function delay (line 96) | fn delay(
FILE: examples/router/src/lib.rs
type ExampleContext (line 17) | struct ExampleContext(i32);
function RouterExample (line 20) | pub fn RouterExample() -> impl IntoView {
function ContactRoutes (line 72) | pub fn ContactRoutes() -> impl leptos_router::MatchNestedRoutes + Clone {
function ContactList (line 83) | pub fn ContactList() -> impl IntoView {
type ContactParams (line 129) | pub struct ContactParams {
function Contact (line 135) | pub fn Contact() -> impl IntoView {
function About (line 184) | pub fn About() -> impl IntoView {
function Settings (line 213) | pub fn Settings() -> impl IntoView {
FILE: examples/router/src/main.rs
function main (line 6) | pub fn main() {
FILE: examples/server_fns_axum/src/app.rs
function shell (line 27) | pub fn shell(options: LeptosOptions) -> impl IntoView {
function App (line 48) | pub fn App() -> impl IntoView {
function HomePage (line 60) | pub fn HomePage() -> impl IntoView {
function SpawnLocal (line 87) | pub fn SpawnLocal() -> impl IntoView {
function add_row (line 138) | pub async fn add_row(text: String) -> Result<usize, ServerFnError> {
function get_rows (line 158) | pub async fn get_rows() -> Result<usize, ServerFnError> {
function WithAnAction (line 173) | pub fn WithAnAction() -> impl IntoView {
function WithActionForm (line 214) | pub fn WithActionForm() -> impl IntoView {
function length_of_input (line 263) | pub async fn length_of_input(input: String) -> Result<usize, ServerFnErr...
function ServerFnArgumentExample (line 271) | pub fn ServerFnArgumentExample() -> impl IntoView {
function rkyv_example (line 308) | pub async fn rkyv_example(input: String) -> Result<String, ServerFnError> {
function RkyvExample (line 315) | pub fn RkyvExample() -> impl IntoView {
function FileUpload (line 336) | pub fn FileUpload() -> impl IntoView {
function FileUploadWithProgress (line 406) | pub fn FileUploadWithProgress() -> impl IntoView {
function FileWatcher (line 579) | pub fn FileWatcher() -> impl IntoView {
function ascii_uppercase (line 663) | pub async fn ascii_uppercase(text: String) -> Result<String, MyErrors> {
function other_error (line 668) | pub fn other_error() -> Result<(), String> {
function ascii_uppercase_inner (line 672) | pub fn ascii_uppercase_inner(text: String) -> Result<String, InvalidArgu...
function ascii_uppercase_classic (line 685) | pub async fn ascii_uppercase_classic(
type InvalidArgument (line 704) | pub enum InvalidArgument {
type MyErrors (line 721) | pub enum MyErrors {
method from (line 728) | fn from(value: InvalidArgument) -> Self {
method from (line 734) | fn from(value: String) -> Self {
type Encoder (line 740) | type Encoder = RkyvEncoding;
method from_server_fn_error (line 742) | fn from_server_fn_error(value: ServerFnErrorErr) -> Self {
function CustomErrorTypes (line 748) | pub fn CustomErrorTypes() -> impl IntoView {
type Toml (line 785) | pub struct Toml;
type TomlEncoded (line 792) | pub struct TomlEncoded<T>(T);
constant CONTENT_TYPE (line 795) | const CONTENT_TYPE: &'static str = "application/toml";
constant FORMAT_TYPE (line 799) | const FORMAT_TYPE: Format = Format::Text;
constant METHOD (line 803) | const METHOD: Method = Method::POST;
function into_req (line 812) | fn into_req(self, path: &str, accepts: &str) -> Result<Request, Err> {
function from_req (line 826) | async fn from_req(req: Request) -> Result<Self, Err> {
function into_res (line 840) | async fn into_res(self) -> Result<Response, Err> {
function from_res (line 854) | async fn from_res(res: Response) -> Result<Self, Err> {
type WhyNotResult (line 863) | pub struct WhyNotResult {
function why_not (line 873) | pub async fn why_not(
function CustomEncoding (line 886) | pub fn CustomEncoding() -> impl IntoView {
function CustomClientExample (line 916) | pub fn CustomClientExample() -> impl IntoView {
type PostcardData (line 994) | pub struct PostcardData {
function postcard_example (line 1004) | pub async fn postcard_example(
function PostcardExample (line 1022) | pub fn PostcardExample() -> impl IntoView {
FILE: examples/server_fns_axum/src/error_template.rs
function ErrorTemplate (line 9) | pub fn ErrorTemplate(
FILE: examples/server_fns_axum/src/errors.rs
type TodoAppError (line 5) | pub enum TodoAppError {
method status_code (line 13) | pub fn status_code(&self) -> StatusCode {
FILE: examples/server_fns_axum/src/lib.rs
function hydrate (line 9) | pub fn hydrate() {
FILE: examples/server_fns_axum/src/main.rs
function main (line 10) | async fn main() {
FILE: examples/server_fns_axum/src/middleware.rs
type LoggingLayer (line 11) | pub struct LoggingLayer;
type Service (line 14) | type Service = LoggingService<S>;
method layer (line 16) | fn layer(&self, inner: S) -> Self::Service {
type LoggingService (line 21) | pub struct LoggingService<T> {
type Response (line 29) | type Response = T::Response;
type Error (line 30) | type Error = T::Error;
type Future (line 31) | type Future = LoggingServiceFuture<T::Future>;
type Output (line 60) | type Output = T::Output;
method poll (line 62) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
function poll_ready (line 33) | fn poll_ready(
function call (line 40) | fn call(&mut self, req: Request<Body>) -> Self::Future {
FILE: examples/slots/src/lib.rs
type Then (line 5) | struct Then {
type ElseIf (line 12) | struct ElseIf {
type Fallback (line 18) | struct Fallback {
function SlotIf (line 24) | fn SlotIf(
function App (line 44) | pub fn App() -> impl IntoView {
FILE: examples/slots/src/main.rs
function main (line 3) | pub fn main() {
FILE: examples/spread/src/lib.rs
function SpreadingExample (line 5) | pub fn SpreadingExample() -> impl IntoView {
function ComponentThatTakesSpread (line 101) | pub fn ComponentThatTakesSpread(some_prop: i32) -> impl IntoView {
FILE: examples/spread/src/main.rs
function main (line 3) | pub fn main() {
FILE: examples/ssr_modes/src/app.rs
function App (line 14) | pub fn App() -> impl IntoView {
function HomePage (line 48) | fn HomePage() -> impl IntoView {
type PostParams (line 84) | pub struct PostParams {
function Post (line 89) | fn Post() -> impl IntoView {
type PostError (line 171) | pub enum PostError {
type Post (line 181) | pub struct Post {
type PostMetadata (line 188) | pub struct PostMetadata {
function list_post_metadata (line 194) | pub async fn list_post_metadata() -> Result<Vec<PostMetadata>, ServerFnE...
function get_post (line 206) | pub async fn get_post(id: usize) -> Result<Option<Post>, ServerFnError> {
FILE: examples/ssr_modes/src/lib.rs
function hydrate (line 5) | pub fn hydrate() {
FILE: examples/ssr_modes/src/main.rs
function main (line 3) | async fn main() -> std::io::Result<()> {
function main (line 51) | pub fn main() {
FILE: examples/ssr_modes_axum/src/app.rs
function shell (line 15) | pub fn shell(options: LeptosOptions) -> impl IntoView {
function is_admin (line 37) | pub async fn is_admin() -> Result<bool, ServerFnError> {
function set_is_admin (line 42) | pub async fn set_is_admin(is_admin: bool) -> Result<(), ServerFnError> {
function App (line 48) | pub fn App() -> impl IntoView {
function HomePage (line 123) | fn HomePage() -> impl IntoView {
type PostParams (line 167) | pub struct PostParams {
function Post (line 172) | fn Post() -> impl IntoView {
function Admin (line 258) | pub fn Admin() -> impl IntoView {
type PostError (line 285) | pub enum PostError {
type Post (line 295) | pub struct Post {
type PostMetadata (line 302) | pub struct PostMetadata {
function list_post_metadata (line 308) | pub async fn list_post_metadata() -> Result<Vec<PostMetadata>, ServerFnE...
function get_post (line 320) | pub async fn get_post(id: usize) -> Result<Option<Post>, ServerFnError> {
function get_comments (line 326) | pub async fn get_comments(id: usize) -> Result<Vec<String>, ServerFnErro...
FILE: examples/ssr_modes_axum/src/lib.rs
function hydrate (line 5) | pub fn hydrate() {
FILE: examples/ssr_modes_axum/src/main.rs
function main (line 3) | async fn main() {
function main (line 53) | pub fn main() {
FILE: examples/static_routing/src/app.rs
function shell (line 16) | pub fn shell(options: LeptosOptions) -> impl IntoView {
function App (line 35) | pub fn App() -> impl IntoView {
function HomePage (line 88) | fn HomePage() -> impl IntoView {
type PostParams (line 113) | pub struct PostParams {
function Post (line 118) | fn Post() -> impl IntoView {
type PostError (line 186) | pub enum PostError {
type Post (line 196) | pub struct Post {
function list_slugs (line 203) | pub async fn list_slugs() -> Result<Vec<String>, ServerFnError> {
function list_posts (line 232) | pub async fn list_posts() -> Result<Vec<Post>, ServerFnError> {
function get_post (line 274) | pub async fn get_post(slug: String) -> Result<Option<Post>, ServerFnErro...
function watch_path (line 289) | fn watch_path(path: &Path) -> impl Stream<Item = ()> {
FILE: examples/static_routing/src/lib.rs
function hydrate (line 5) | pub fn hydrate() {
FILE: examples/static_routing/src/main.rs
function main (line 3) | async fn main() {
function main (line 38) | pub fn main() {
FILE: examples/stores/src/lib.rs
type Todos (line 17) | struct Todos {
method data (line 29) | fn data() -> Self {
type User (line 58) | struct User {
type Todo (line 64) | struct Todo {
method new (line 70) | pub fn new(label: impl ToString) -> Self {
type Status (line 80) | enum Status {
method next_step (line 90) | pub fn next_step(&mut self) {
method patch_field (line 102) | fn patch_field(
function App (line 117) | pub fn App() -> impl IntoView {
function UserForm (line 148) | fn UserForm(#[prop(into)] user: Field<User>) -> impl IntoView {
function UserAchievements (line 175) | fn UserAchievements(store: Store<Todos>) -> impl IntoView {
function TodoRow (line 195) | fn TodoRow(
FILE: examples/stores/src/main.rs
function main (line 4) | pub fn main() {
FILE: examples/subsecond_hot_patch/src/main.rs
function main (line 7) | fn main() {
function App (line 17) | fn App() -> impl IntoView {
function HomePage (line 33) | fn HomePage() -> impl IntoView {
function About (line 40) | fn About() -> impl IntoView {
FILE: examples/suspense_tests/e2e/tests/app_suite.rs
function main (line 9) | async fn main() -> Result<()> {
FILE: examples/suspense_tests/e2e/tests/fixtures/action.rs
function goto_path (line 6) | pub async fn goto_path(client: &Client, path: &str) -> Result<()> {
function click_link (line 13) | pub async fn click_link(client: &Client, text: &str) -> Result<()> {
function click_first_button (line 25) | pub async fn click_first_button(client: &Client) -> Result<()> {
function click_second_button (line 33) | pub async fn click_second_button(client: &Client) -> Result<()> {
function click_reset_counters_button (line 41) | pub async fn click_reset_counters_button(client: &Client) -> Result<()> {
function click_reset_csr_counters_button (line 49) | pub async fn click_reset_csr_counters_button(client: &Client) -> Result<...
FILE: examples/suspense_tests/e2e/tests/fixtures/check.rs
function page_title_is (line 6) | pub async fn page_title_is(client: &Client, expected_text: &str) -> Resu...
function loaded_one_message_is (line 13) | pub async fn loaded_one_message_is(
function loaded_two_message_is (line 23) | pub async fn loaded_two_message_is(
function inside_message_is (line 33) | pub async fn inside_message_is(
function following_message_is (line 43) | pub async fn following_message_is(
function first_count_is (line 53) | pub async fn first_count_is(client: &Client, expected: u32) -> Result<()> {
function second_count_is (line 60) | pub async fn second_count_is(client: &Client, expected: u32) -> Result<(...
function instrumented_counts (line 67) | pub async fn instrumented_counts(
function link_text_is_aria_current (line 83) | pub async fn link_text_is_aria_current(
function link_text_is_not_aria_current (line 96) | pub async fn link_text_is_not_aria_current(
FILE: examples/suspense_tests/e2e/tests/fixtures/find.rs
function page_title (line 4) | pub async fn page_title(client: &Client) -> Result<String> {
function loaded_one_message (line 20) | pub async fn loaded_one_message(client: &Client) -> Result<String> {
function loaded_two_message (line 26) | pub async fn loaded_two_message(client: &Client) -> Result<String> {
function following_message (line 32) | pub async fn following_message(client: &Client) -> Result<String> {
function inside_message (line 38) | pub async fn inside_message(client: &Client) -> Result<String> {
function first_count (line 44) | pub async fn first_count(client: &Client) -> Result<u32> {
function first_button (line 52) | pub async fn first_button(client: &Client) -> Result<Element> {
function second_count (line 62) | pub async fn second_count(client: &Client) -> Result<u32> {
function second_button (line 70) | pub async fn second_button(client: &Client) -> Result<Element> {
function instrumented_count (line 80) | pub async fn instrumented_count(
function reset_counter (line 96) | pub async fn reset_counter(client: &Client) -> Result<Element> {
function reset_csr_counter (line 106) | pub async fn reset_csr_counter(client: &Client) -> Result<Element> {
function component_message (line 116) | async fn component_message(client: &Client, id: &str) -> Result<String> {
function link_with_text (line 127) | pub async fn link_with_text(client: &Client, text: &str) -> Result<Eleme...
FILE: examples/suspense_tests/e2e/tests/fixtures/world/action_steps.rs
function i_open_the_app (line 7) | async fn i_open_the_app(world: &mut AppWorld) -> Result<()> {
function i_select_the_link (line 21) | async fn i_select_the_link(world: &mut AppWorld, text: String) -> Result...
function i_click_the_first_button_n_times (line 30) | async fn i_click_the_first_button_n_times(
function i_click_the_second_button_n_times (line 44) | async fn i_click_the_second_button_n_times(
function i_refresh_the_browser (line 59) | async fn i_refresh_the_browser(world: &mut AppWorld) -> Result<()> {
function i_click_on_reset_counters (line 67) | async fn i_click_on_reset_counters(world: &mut AppWorld) -> Result<()> {
function i_click_on_reset_csr_counters (line 76) | async fn i_click_on_reset_csr_counters(world: &mut AppWorld) -> Result<(...
function i_access_the_instrumented_counters_page_via_ssr (line 84) | async fn i_access_the_instrumented_counters_page_via_ssr(
function i_access_the_instrumented_counters_page_via_csr (line 96) | async fn i_access_the_instrumented_counters_page_via_csr(
function i_select_the_following_links (line 108) | async fn i_select_the_following_links(
FILE: examples/suspense_tests/e2e/tests/fixtures/world/check_steps.rs
function i_see_the_page_title_is (line 6) | async fn i_see_the_page_title_is(
function i_see_the_one_second_message_is (line 17) | async fn i_see_the_one_second_message_is(
function i_see_the_two_second_message_is (line 28) | async fn i_see_the_two_second_message_is(
function i_see_the_following_message_is (line 39) | async fn i_see_the_following_message_is(
function i_see_the_inside_message_is (line 50) | async fn i_see_the_inside_message_is(
function i_see_the_first_count_is (line 62) | async fn i_see_the_first_count_is(
function i_see_the_second_count_is (line 73) | async fn i_see_the_second_count_is(
function i_see_the_link_being_bolded (line 84) | async fn i_see_the_link_being_bolded(
function i_see_the_following_links_being_bolded (line 95) | async fn i_see_the_following_links_being_bolded(
function i_see_the_link_being_not_bolded (line 110) | async fn i_see_the_link_being_not_bolded(
function i_see_the_following_links_not_being_bolded (line 121) | async fn i_see_the_following_links_not_being_bolded(
function i_see_the_following_counters_under_section (line 137) | async fn i_see_the_following_counters_under_section(
FILE: examples/suspense_tests/e2e/tests/fixtures/world/mod.rs
constant HOST (line 10) | pub const HOST: &str = "http://127.0.0.1:3000";
type AppWorld (line 14) | pub struct AppWorld {
method new (line 19) | async fn new() -> Result<Self, anyhow::Error> {
function build_client (line 28) | async fn build_client() -> Result<Client, NewSessionError> {
FILE: examples/suspense_tests/src/app.rs
constant WAIT_ONE_SECOND (line 8) | const WAIT_ONE_SECOND: u64 = 1;
constant WAIT_TWO_SECONDS (line 9) | const WAIT_TWO_SECONDS: u64 = 2;
function first_wait_fn (line 12) | async fn first_wait_fn(seconds: u64) -> Result<(), ServerFnError> {
function second_wait_fn (line 19) | async fn second_wait_fn(seconds: u64) -> Result<(), ServerFnError> {
function App (line 26) | pub fn App() -> impl IntoView {
function SecondaryNav (line 123) | fn SecondaryNav() -> impl IntoView {
function Nested (line 142) | fn Nested() -> impl IntoView {
function NestedResourceInside (line 177) | fn NestedResourceInside() -> impl IntoView {
function Parallel (line 210) | fn Parallel() -> impl IntoView {
function Single (line 257) | fn Single() -> impl IntoView {
function InsideComponent (line 280) | fn InsideComponent() -> impl IntoView {
function InsideComponentChild (line 296) | fn InsideComponentChild() -> impl IntoView {
function LocalResource (line 311) | fn LocalResource() -> impl IntoView {
function None (line 341) | fn None() -> impl IntoView {
FILE: examples/suspense_tests/src/instrumented.rs
type Counter (line 21) | pub struct Counter(AtomicU32);
method new (line 25) | pub const fn new() -> Self {
method get (line 29) | pub fn get(&self) -> u32 {
method inc (line 33) | pub fn inc(&self) -> u32 {
method reset (line 37) | pub fn reset(&self) {
type Counters (line 43) | pub struct Counters {
method reset (line 62) | pub fn reset(&self) {
function from (line 51) | fn from(counter: &mut Counters) -> Self {
type Item (line 75) | pub struct Item {
function list_items (line 82) | async fn list_items(ticket: u64) -> Result<Vec<i64>, ServerFnError> {
type GetItemResult (line 96) | pub struct GetItemResult(pub Item, pub Vec<String>);
function get_item (line 99) | async fn get_item(
type InspectItemResult (line 124) | pub struct InspectItemResult(pub Item, pub String, pub Vec<String>);
function inspect_item (line 127) | async fn inspect_item(
type Counters (line 170) | pub struct Counters {
method reset (line 62) | pub fn reset(&self) {
function get_counters (line 178) | async fn get_counters(ticket: u64) -> Result<Counters, ServerFnError> {
function reset_counters (line 188) | async fn reset_counters(ticket: u64) -> Result<(), ServerFnError> {
type SuspenseCounters (line 200) | pub struct SuspenseCounters {
function InstrumentedRoutes (line 207) | pub fn InstrumentedRoutes() -> impl leptos_router::MatchNestedRoutes + C...
type Ticket (line 227) | pub struct Ticket(pub u64);
type CSRTicket (line 230) | pub struct CSRTicket(pub u64);
function inst_ticket (line 233) | fn inst_ticket() -> u64 {
function inst_ticket (line 239) | fn inst_ticket() -> u64 {
function InstrumentedRoot (line 245) | fn InstrumentedRoot() -> impl IntoView {
function InstrumentedTop (line 333) | fn InstrumentedTop() -> impl IntoView {
function ItemRoot (line 352) | fn ItemRoot() -> impl IntoView {
function ItemListing (line 366) | fn ItemListing() -> impl IntoView {
type ItemTopParams (line 400) | struct ItemTopParams {
function ItemTop (line 405) | fn ItemTop() -> impl IntoView {
function ItemOverview (line 426) | fn ItemOverview() -> impl IntoView {
type ItemInspectParams (line 466) | struct ItemInspectParams {
function ItemInspect (line 471) | fn ItemInspect() -> impl IntoView {
function ShowCounters (line 560) | fn ShowCounters() -> impl IntoView {
type FieldNavItem (line 649) | pub struct FieldNavItem {
type FieldNavCtx (line 655) | pub struct FieldNavCtx(pub Option<Vec<FieldNavItem>>);
method from (line 658) | fn from(item: Vec<FieldNavItem>) -> Self {
function FieldNavPortlet (line 664) | pub fn FieldNavPortlet() -> impl IntoView {
function provide_field_nav_portlet_context (line 687) | pub fn provide_field_nav_portlet_context() {
FILE: examples/suspense_tests/src/lib.rs
function hydrate (line 6) | pub fn hydrate() {
FILE: examples/suspense_tests/src/main.rs
function main (line 3) | async fn main() -> std::io::Result<()> {
function main (line 53) | pub fn main() {
FILE: examples/tailwind_actix/src/app.rs
function App (line 9) | pub fn App() -> impl IntoView {
function Home (line 24) | fn Home() -> impl IntoView {
FILE: examples/tailwind_actix/src/lib.rs
function hydrate (line 5) | pub fn hydrate() {
FILE: examples/tailwind_actix/src/main.rs
function main (line 11) | async fn main() -> std::io::Result<()> {
FILE: examples/tailwind_axum/src/app.rs
function shell (line 8) | pub fn shell(options: LeptosOptions) -> impl IntoView {
function App (line 29) | pub fn App() -> impl IntoView {
function Home (line 42) | fn Home() -> impl IntoView {
FILE: examples/tailwind_axum/src/lib.rs
function hydrate (line 5) | pub fn hydrate() {
FILE: examples/tailwind_axum/src/main.rs
function main (line 7) | async fn main() {
function main (line 33) | pub fn main() {
FILE: examples/tailwind_csr/src/app.rs
function App (line 9) | pub fn App() -> impl IntoView {
function Home (line 24) | fn Home() -> impl IntoView {
FILE: examples/tailwind_csr/src/main.rs
function main (line 6) | pub fn main() {
FILE: examples/timer/src/lib.rs
function TimerDemo (line 6) | pub fn TimerDemo() -> impl IntoView {
function use_interval (line 38) | pub fn use_interval<T, F>(interval_millis: T, f: F)
FILE: examples/timer/src/main.rs
function main (line 4) | pub fn main() {
FILE: examples/todo_app_sqlite/e2e/tests/app_suite.rs
function main (line 8) | async fn main() -> Result<()> {
FILE: examples/todo_app_sqlite/e2e/tests/fixtures/action.rs
function goto_path (line 7) | pub async fn goto_path(client: &Client, path: &str) -> Result<()> {
function add_todo (line 14) | pub async fn add_todo(client: &Client, text: &str) -> Result<()> {
function fill_todo (line 20) | pub async fn fill_todo(client: &Client, text: &str) -> Result<()> {
function click_add_button (line 27) | pub async fn click_add_button(client: &Client) -> Result<()> {
function empty_todo_list (line 34) | pub async fn empty_todo_list(client: &Client) -> Result<()> {
function delete_first_todo (line 44) | pub async fn delete_first_todo(client: &Client) -> Result<()> {
function delete_todo (line 53) | pub async fn delete_todo(client: &Client, text: &str) -> Result<()> {
FILE: examples/todo_app_sqlite/e2e/tests/fixtures/check.rs
function text_on_element (line 6) | pub async fn text_on_element(
function todo_present (line 26) | pub async fn todo_present(
function is_todo_present (line 38) | async fn is_todo_present(client: &Client, text: &str) -> bool {
function todo_is_pending (line 51) | pub async fn todo_is_pending(client: &Client) -> Result<()> {
FILE: examples/todo_app_sqlite/e2e/tests/fixtures/find.rs
function todo_input (line 3) | pub async fn todo_input(client: &Client) -> Element {
function add_button (line 13) | pub async fn add_button(client: &Client) -> Element {
function first_delete_button (line 23) | pub async fn first_delete_button(client: &Client) -> Option<Element> {
function delete_button (line 35) | pub async fn delete_button(client: &Client, text: &str) -> Option<Elemen...
function pending_todo (line 46) | pub async fn pending_todo(client: &Client) -> Option<Element> {
function todos (line 56) | pub async fn todos(client: &Client) -> Vec<Element> {
FILE: examples/todo_app_sqlite/e2e/tests/fixtures/world/action_steps.rs
function i_open_the_app (line 7) | async fn i_open_the_app(world: &mut AppWorld) -> Result<()> {
function i_add_a_todo_titled (line 16) | async fn i_add_a_todo_titled(world: &mut AppWorld, text: String) -> Resu...
function i_set_the_todo_as (line 24) | async fn i_set_the_todo_as(world: &mut AppWorld, text: String) -> Result...
function i_click_the_button (line 32) | async fn i_click_the_button(world: &mut AppWorld) -> Result<()> {
function i_delete_the_todo_named (line 40) | async fn i_delete_the_todo_named(
function i_empty_the_todo_list (line 52) | async fn i_empty_the_todo_list(world: &mut AppWorld) -> Result<()> {
FILE: examples/todo_app_sqlite/e2e/tests/fixtures/world/check_steps.rs
function i_see_the_page_title_is (line 6) | async fn i_see_the_page_title_is(
function i_see_the_label_of_the_input_is (line 17) | async fn i_see_the_label_of_the_input_is(
function i_see_the_todo_is_present (line 28) | async fn i_see_the_todo_is_present(
function i_see_the_pending_todo (line 39) | async fn i_see_the_pending_todo(world: &mut AppWorld) -> Result<()> {
function i_see_the_empty_list_message_is (line 48) | async fn i_see_the_empty_list_message_is(
function i_do_not_see_the_todo_is_present (line 59) | async fn i_do_not_see_the_todo_is_present(
FILE: examples/todo_app_sqlite/e2e/tests/fixtures/world/mod.rs
constant HOST (line 10) | pub const HOST: &str = "http://127.0.0.1:3000";
type AppWorld (line 14) | pub struct AppWorld {
method new (line 19) | async fn new() -> Result<Self, anyhow::Error> {
function build_client (line 28) | async fn build_client() -> Result<Client, NewSessionError> {
FILE: examples/todo_app_sqlite/migrations/20221118172000_create_todo_table.sql
type todos (line 1) | CREATE TABLE IF NOT EXISTS todos
FILE: examples/todo_app_sqlite/src/lib.rs
function hydrate (line 5) | pub fn hydrate() {
FILE: examples/todo_app_sqlite/src/main.rs
function css (line 12) | pub async fn css() -> impl Responder {
function main (line 19) | async fn main() -> std::io::Result<()> {
FILE: examples/todo_app_sqlite/src/todo.rs
type Todo (line 7) | pub struct Todo {
function db (line 19) | pub async fn db() -> Result<SqliteConnection, ServerFnError> {
function get_todos (line 25) | pub async fn get_todos() -> Result<Vec<Todo>, ServerFnError> {
function add_todo (line 55) | pub async fn add_todo(title: String) -> Result<(), ServerFnError> {
function delete_todo (line 73) | pub async fn delete_todo(id: u16) -> Result<(), ServerFnError> {
function TodoApp (line 85) | pub fn TodoApp() -> impl IntoView {
function Todos (line 97) | pub fn Todos() -> impl IntoView {
FILE: examples/todo_app_sqlite_axum/e2e/tests/app_suite.rs
function main (line 8) | async fn main() -> Result<()> {
FILE: examples/todo_app_sqlite_axum/e2e/tests/fixtures/action.rs
function goto_path (line 7) | pub async fn goto_path(client: &Client, path: &str) -> Result<()> {
function add_todo (line 14) | pub async fn add_todo(client: &Client, text: &str) -> Result<()> {
function fill_todo (line 20) | pub async fn fill_todo(client: &Client, text: &str) -> Result<()> {
function click_add_button (line 27) | pub async fn click_add_button(client: &Client) -> Result<()> {
function empty_todo_list (line 34) | pub async fn empty_todo_list(client: &Client) -> Result<()> {
function delete_first_todo (line 44) | pub async fn delete_first_todo(client: &Client) -> Result<()> {
function delete_todo (line 53) | pub async fn delete_todo(client: &Client, text: &str) -> Result<()> {
FILE: examples/todo_app_sqlite_axum/e2e/tests/fixtures/check.rs
function text_on_element (line 6) | pub async fn text_on_element(
function todo_present (line 26) | pub async fn todo_present(
function is_todo_present (line 38) | async fn is_todo_present(client: &Client, text: &str) -> bool {
function todo_is_pending (line 51) | pub async fn todo_is_pending(client: &Client) -> Result<()> {
FILE: examples/todo_app_sqlite_axum/e2e/tests/fixtures/find.rs
function todo_input (line 3) | pub async fn todo_input(client: &Client) -> Element {
function add_button (line 13) | pub async fn add_button(client: &Client) -> Element {
function first_delete_button (line 23) | pub async fn first_delete_button(client: &Client) -> Option<Element> {
function delete_button (line 35) | pub async fn delete_button(client: &Client, text: &str) -> Option<Elemen...
function pending_todo (line 46) | pub async fn pending_todo(client: &Client) -> Option<Element> {
function todos (line 56) | pub async fn todos(client: &Client) -> Vec<Element> {
FILE: examples/todo_app_sqlite_axum/e2e/tests/fixtures/world/action_steps.rs
function i_open_the_app (line 7) | async fn i_open_the_app(world: &mut AppWorld) -> Result<()> {
function i_add_a_todo_titled (line 16) | async fn i_add_a_todo_titled(world: &mut AppWorld, text: String) -> Resu...
function i_set_the_todo_as (line 24) | async fn i_set_the_todo_as(world: &mut AppWorld, text: String) -> Result...
function i_click_the_button (line 32) | async fn i_click_the_button(world: &mut AppWorld) -> Result<()> {
function i_delete_the_todo_named (line 40) | async fn i_delete_the_todo_named(
function i_empty_the_todo_list (line 52) | async fn i_empty_the_todo_list(world: &mut AppWorld) -> Result<()> {
FILE: examples/todo_app_sqlite_axum/e2e/tests/fixtures/world/check_steps.rs
function i_see_the_page_title_is (line 6) | async fn i_see_the_page_title_is(
function i_see_the_label_of_the_input_is (line 17) | async fn i_see_the_label_of_the_input_is(
function i_see_the_todo_is_present (line 28) | async fn i_see_the_todo_is_present(
function i_see_the_pending_todo (line 39) | async fn i_see_the_pending_todo(world: &mut AppWorld) -> Result<()> {
function i_see_the_empty_list_message_is (line 48) | async fn i_see_the_empty_list_message_is(
function i_do_not_see_the_todo_is_present (line 59) | async fn i_do_not_see_the_todo_is_present(
FILE: examples/todo_app_sqlite_axum/e2e/tests/fixtures/world/mod.rs
constant HOST (line 10) | pub const HOST: &str = "http://127.0.0.1:3000";
type AppWorld (line 14) | pub struct AppWorld {
method new (line 19) | async fn new() -> Result<Self, anyhow::Error> {
function build_client (line 28) | async fn build_client() -> Result<Client, NewSessionError> {
FILE: examples/todo_app_sqlite_axum/migrations/20221118172000_create_todo_table.sql
type todos (line 2) | CREATE TABLE IF NOT EXISTS todos
FILE: examples/todo_app_sqlite_axum/src/error_template.rs
function ErrorTemplate (line 6) | pub fn ErrorTemplate(
FILE: examples/todo_app_sqlite_axum/src/errors.rs
type TodoAppError (line 5) | pub enum TodoAppError {
method status_code (line 13) | pub fn status_code(&self) -> StatusCode {
FILE: examples/todo_app_sqlite_axum/src/lib.rs
function hydrate (line 7) | pub fn hydrate() {
FILE: examples/todo_app_sqlite_axum/src/main.rs
function custom_handler (line 14) | async fn custom_handler(
function main (line 29) | async fn main() {
function main (line 67) | pub fn main() {
FILE: examples/todo_app_sqlite_axum/src/todo.rs
function shell (line 6) | pub fn shell(options: LeptosOptions) -> impl IntoView {
type Todo (line 27) | pub struct Todo {
function db (line 39) | pub async fn db() -> Result<SqliteConnection, ServerFnError> {
function get_todos (line 45) | pub async fn get_todos() -> Result<Vec<Todo>, ServerFnError> {
function add_todo (line 76) | pub async fn add_todo(title: String) -> Result<(), ServerFnError> {
function delete_todo (line 94) | pub async fn delete_todo(id: u16) -> Result<(), ServerFnError> {
function TodoApp (line 106) | pub fn TodoApp() -> impl IntoView {
function Todos (line 118) | pub fn Todos() -> impl IntoView {
FILE: examples/todo_app_sqlite_csr/e2e/tests/app_suite.rs
function main (line 8) | async fn main() -> Result<()> {
FILE: examples/todo_app_sqlite_csr/e2e/tests/fixtures/action.rs
function goto_path (line 7) | pub async fn goto_path(client: &Client, path: &str) -> Result<()> {
function add_todo (line 14) | pub async fn add_todo(client: &Client, text: &str) -> Result<()> {
function fill_todo (line 20) | pub async fn fill_todo(client: &Client, text: &str) -> Result<()> {
function click_add_button (line 27) | pub async fn click_add_button(client: &Client) -> Result<()> {
function empty_todo_list (line 34) | pub async fn empty_todo_list(client: &Client) -> Result<()> {
function delete_first_todo (line 44) | pub async fn delete_first_todo(client: &Client) -> Result<()> {
function delete_todo (line 53) | pub async fn delete_todo(client: &Client, text: &str) -> Result<()> {
FILE: examples/todo_app_sqlite_csr/e2e/tests/fixtures/check.rs
function text_on_element (line 6) | pub async fn text_on_element(
function todo_present (line 26) | pub async fn todo_present(
function is_todo_present (line 38) | async fn is_todo_present(client: &Client, text: &str) -> bool {
function todo_is_pending (line 51) | pub async fn todo_is_pending(client: &Client) -> Result<()> {
FILE: examples/todo_app_sqlite_csr/e2e/tests/fixtures/find.rs
function todo_input (line 3) | pub async fn todo_input(client: &Client) -> Element {
function add_button (line 13) | pub async fn add_button(client: &Client) -> Element {
function first_delete_button (line 23) | pub async fn first_delete_button(client: &Client) -> Option<Element> {
function delete_button (line 35) | pub async fn delete_button(client: &Client, text: &str) -> Option<Elemen...
function pending_todo (line 46) | pub async fn pending_todo(client: &Client) -> Option<Element> {
function todos (line 56) | pub async fn todos(client: &Client) -> Vec<Element> {
FILE: examples/todo_app_sqlite_csr/e2e/tests/fixtures/world/action_steps.rs
function i_open_the_app (line 7) | async fn i_open_the_app(world: &mut AppWorld) -> Result<()> {
function i_add_a_todo_titled (line 16) | async fn i_add_a_todo_titled(world: &mut AppWorld, text: String) -> Resu...
function i_set_the_todo_as (line 24) | async fn i_set_the_todo_as(world: &mut AppWorld, text: String) -> Result...
function i_click_the_button (line 32) | async fn i_click_the_button(world: &mut AppWorld) -> Result<()> {
function i_delete_the_todo_named (line 40) | async fn i_delete_the_todo_named(
function i_empty_the_todo_list (line 52) | async fn i_empty_the_todo_list(world: &mut AppWorld) -> Result<()> {
FILE: examples/todo_app_sqlite_csr/e2e/tests/fixtures/world/check_steps.rs
function i_see_the_page_title_is (line 6) | async fn i_see_the_page_title_is(
function i_see_the_label_of_the_input_is (line 17) | async fn i_see_the_label_of_the_input_is(
function i_see_the_todo_is_present (line 28) | async fn i_see_the_todo_is_present(
function i_see_the_pending_todo (line 39) | async fn i_see_the_pending_todo(world: &mut AppWorld) -> Result<()> {
function i_see_the_empty_list_message_is (line 48) | async fn i_see_the_empty_list_message_is(
function i_do_not_see_the_todo_is_present (line 59) | async fn i_do_not_see_the_todo_is_present(
FILE: examples/todo_app_sqlite_csr/e2e/tests/fixtures/world/mod.rs
constant HOST (line 10) | pub const HOST: &str = "http://127.0.0.1:3000";
type AppWorld (line 14) | pub struct AppWorld {
method new (line 19) | async fn new() -> Result<Self, anyhow::Error> {
function build_client (line 28) | async fn build_client() -> Result<Client, NewSessionError> {
FILE: examples/todo_app_sqlite_csr/migrations/20221118172000_create_todo_table.sql
type todos (line 2) | CREATE TABLE IF NOT EXISTS todos
FILE: examples/todo_app_sqlite_csr/src/error_template.rs
function ErrorTemplate (line 9) | pub fn ErrorTemplate(
FILE: examples/todo_app_sqlite_csr/src/errors.rs
type TodoAppError (line 5) | pub enum TodoAppError {
method status_code (line 13) | pub fn status_code(&self) -> StatusCode {
FILE: examples/todo_app_sqlite_csr/src/fallback.rs
function file_or_index_handler (line 15) | pub async fn file_or_index_handler(
function get_static_file (line 42) | async fn get_static_file(
FILE: examples/todo_app_sqlite_csr/src/lib.rs
function hydrate (line 8) | pub fn hydrate() {
FILE: examples/todo_app_sqlite_csr/src/main.rs
function main (line 21) | async fn main() {
function main (line 53) | pub fn main() {
FILE: examples/todo_app_sqlite_csr/src/todo.rs
type Todo (line 8) | pub struct Todo {
function db (line 20) | pub async fn db() -> Result<SqliteConnection, ServerFnError> {
function get_todos (line 26) | pub async fn get_todos() -> Result<Vec<Todo>, ServerFnError> {
function add_todo (line 57) | pub async fn add_todo(title: String) -> Result<(), ServerFnError> {
function delete_todo (line 75) | pub async fn delete_todo(id: u16) -> Result<(), ServerFnError> {
function TodoApp (line 87) | pub fn TodoApp() -> impl IntoView {
function Todos (line 99) | pub fn Todos() -> impl IntoView {
FILE: examples/todomvc/src/lib.rs
type Todos (line 7) | pub struct Todos(pub Vec<Todo>);
method is_empty (line 30) | pub fn is_empty(&self) -> bool {
method add (line 34) | pub fn add(&mut self, todo: Todo) {
method remove (line 38) | pub fn remove(&mut self, id: Uuid) {
method remaining (line 42) | pub fn remaining(&self) -> usize {
method completed (line 47) | pub fn completed(&self) -> usize {
method toggle_all (line 52) | pub fn toggle_all(&self) {
method clear_completed (line 71) | fn clear_completed(&mut self) {
method retain (line 75) | fn retain(&mut self, mut f: impl FnMut(&Todo) -> bool) {
constant STORAGE_KEY (line 9) | const STORAGE_KEY: &str = "todos-leptos";
method default (line 12) | fn default() -> Self {
type Todo (line 93) | pub struct Todo {
method new (line 100) | pub fn new(id: Uuid, title: String) -> Self {
method new_with_completed (line 104) | pub fn new_with_completed(
method toggle (line 121) | pub fn toggle(&self) {
constant ESCAPE_KEY (line 128) | const ESCAPE_KEY: u32 = 27;
constant ENTER_KEY (line 129) | const ENTER_KEY: u32 = 13;
function TodoMVC (line 132) | pub fn TodoMVC() -> impl IntoView {
function Todo (line 296) | pub fn Todo(todo: Todo) -> impl IntoView {
method new (line 100) | pub fn new(id: Uuid, title: String) -> Self {
method new_with_completed (line 104) | pub fn new_with_completed(
method toggle (line 121) | pub fn toggle(&self) {
type Mode (line 362) | pub enum Mode {
function route (line 369) | pub fn route(hash: &str) -> Mode {
FILE: examples/todomvc/src/main.rs
function main (line 3) | fn main() {
FILE: examples/websocket/e2e/tests/app_suite.rs
function main (line 8) | async fn main() -> Result<()> {
FILE: examples/websocket/e2e/tests/fixtures/action.rs
function goto_path (line 6) | pub async fn goto_path(client: &Client, path: &str) -> Result<()> {
function fill_input (line 13) | pub async fn fill_input(client: &Client, text: &str) -> Result<()> {
FILE: examples/websocket/e2e/tests/fixtures/check.rs
function text_on_element (line 5) | pub async fn text_on_element(
FILE: examples/websocket/e2e/tests/fixtures/find.rs
function input (line 3) | pub async fn input(client: &Client) -> Element {
FILE: examples/websocket/e2e/tests/fixtures/world/action_steps.rs
function i_open_the_app (line 7) | async fn i_open_the_app(world: &mut AppWorld) -> Result<()> {
function i_add_a_text (line 15) | async fn i_add_a_text(world: &mut AppWorld, text: String) -> Result<()> {
FILE: examples/websocket/e2e/tests/fixtures/world/check_steps.rs
function i_see_the_page_title_is (line 8) | async fn i_see_the_page_title_is(
function i_see_the_label_of_the_input_is (line 19) | async fn i_see_the_label_of_the_input_is(
FILE: examples/websocket/e2e/tests/fixtures/world/mod.rs
constant HOST (line 10) | pub const HOST: &str = "http://127.0.0.1:3000";
type AppWorld (line 14) | pub struct AppWorld {
method new (line 19) | async fn new() -> Result<Self, anyhow::Error> {
function build_client (line 28) | async fn build_client() -> Result<Client, NewSessionError> {
FILE: examples/websocket/src/lib.rs
function hydrate (line 5) | pub fn hydrate() {
FILE: examples/websocket/src/main.rs
function main (line 3) | async fn main() {
function main (line 37) | pub fn main() {
FILE: examples/websocket/src/websocket.rs
function shell (line 4) | pub fn shell(options: LeptosOptions) -> impl IntoView {
function echo_websocket (line 28) | async fn echo_websocket(
function App (line 61) | pub fn App() -> impl IntoView {
FILE: hydration_context/src/csr.rs
type CsrSharedContext (line 6) | pub struct CsrSharedContext;
method is_browser (line 10) | fn is_browser(&self) -> bool {
method next_id (line 15) | fn next_id(&self) -> SerializedDataId {
method write_async (line 20) | fn write_async(&self, _id: SerializedDataId, _fut: PinnedFuture<String>) {}
method read_data (line 23) | fn read_data(&self, _id: &SerializedDataId) -> Option<String> {
method await_data (line 28) | fn await_data(&self, _id: &SerializedDataId) -> Option<String> {
method pending_data (line 33) | fn pending_data(&self) -> Option<PinnedStream<String>> {
method get_is_hydrating (line 38) | fn get_is_hydrating(&self) -> bool {
method set_is_hydrating (line 43) | fn set_is_hydrating(&self, _is_hydrating: bool) {}
method errors (line 46) | fn errors(
method take_errors (line 54) | fn take_errors(
method register_error (line 61) | fn register_error(
method seal_errors (line 70) | fn seal_errors(&self, _boundary_id: &SerializedDataId) {}
method during_hydration (line 73) | fn during_hydration(&self) -> bool {
method hydration_complete (line 78) | fn hydration_complete(&self) {}
method defer_stream (line 81) | fn defer_stream(&self, _wait_for: PinnedFuture<()>) {}
method await_deferred (line 84) | fn await_deferred(&self) -> Option<PinnedFuture<()>> {
method set_incomplete_chunk (line 89) | fn set_incomplete_chunk(&self, _id: SerializedDataId) {}
method get_incomplete_chunk (line 92) | fn get_incomplete_chunk(&self, _id: &SerializedDataId) -> bool {
FILE: hydration_context/src/hydrate.rs
function serialized_errors (line 32) | fn serialized_errors() -> Vec<(SerializedDataId, ErrorId, Error)> {
function incomplete_chunks (line 55) | fn incomplete_chunks() -> Vec<SerializedDataId> {
type SerializedError (line 68) | struct SerializedError(String);
method fmt (line 71) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
type HydrateSharedContext (line 80) | pub struct HydrateSharedContext {
method new (line 90) | pub fn new() -> Self {
method new_islands (line 104) | pub fn new_islands() -> Self {
method fmt (line 116) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
method is_browser (line 122) | fn is_browser(&self) -> bool {
method next_id (line 126) | fn next_id(&self) -> SerializedDataId {
method write_async (line 131) | fn write_async(&self, _id: SerializedDataId, _fut: PinnedFuture<String>) {}
method read_data (line 133) | fn read_data(&self, id: &SerializedDataId) -> Option<String> {
method await_data (line 137) | fn await_data(&self, _id: &SerializedDataId) -> Option<String> {
method pending_data (line 141) | fn pending_data(&self) -> Option<PinnedStream<String>> {
method during_hydration (line 145) | fn during_hydration(&self) -> bool {
method hydration_complete (line 149) | fn hydration_complete(&self) {
method get_is_hydrating (line 153) | fn get_is_hydrating(&self) -> bool {
method set_is_hydrating (line 157) | fn set_is_hydrating(&self, is_hydrating: bool) {
method errors (line 161) | fn errors(&self, boundary_id: &SerializedDataId) -> Vec<(ErrorId, Error)> {
method register_error (line 175) | fn register_error(
method seal_errors (line 184) | fn seal_errors(&self, _boundary_id: &SerializedDataId) {}
method take_errors (line 186) | fn take_errors(&self) -> Vec<(SerializedDataId, ErrorId, Error)> {
method defer_stream (line 191) | fn defer_stream(&self, _wait_for: PinnedFuture<()>) {}
method await_deferred (line 194) | fn await_deferred(&self) -> Option<PinnedFuture<()>> {
method set_incomplete_chunk (line 199) | fn set_incomplete_chunk(&self, _id: SerializedDataId) {}
method get_incomplete_chunk (line 201) | fn get_incomplete_chunk(&self, id: &SerializedDataId) -> bool {
FILE: hydration_context/src/lib.rs
type PinnedFuture (line 33) | pub type PinnedFuture<T> = Pin<Box<dyn Future<Output = T> + Send + Sync>>;
type PinnedLocalFuture (line 35) | pub type PinnedLocalFuture<T> = Pin<Box<dyn Future<Output = T>>>;
type PinnedStream (line 37) | pub type PinnedStream<T> = Pin<Box<dyn Stream<Item = T> + Send + Sync>>;
type SerializedDataId (line 45) | pub struct SerializedDataId(usize);
method new (line 49) | pub fn new(id: usize) -> Self {
method into_inner (line 54) | pub fn into_inner(self) -> usize {
method from (line 60) | fn from(value: SerializedDataId) -> Self {
type SharedContext (line 66) | pub trait SharedContext: Debug {
method is_browser (line 68) | fn is_browser(&self) -> bool;
method next_id (line 75) | fn next_id(&self) -> SerializedDataId;
method write_async (line 82) | fn write_async(&self, id: SerializedDataId, fut: PinnedFuture<String>);
method read_data (line 90) | fn read_data(&self, id: &SerializedDataId) -> Option<String>;
method await_data (line 97) | fn await_data(&self, id: &SerializedDataId) -> Option<String>;
method pending_data (line 104) | fn pending_data(&self) -> Option<PinnedStream<String>>;
method during_hydration (line 110) | fn during_hydration(&self) -> bool;
method hydration_complete (line 113) | fn hydration_complete(&self);
method get_is_hydrating (line 120) | fn get_is_hydrating(&self) -> bool;
method set_is_hydrating (line 126) | fn set_is_hydrating(&self, is_hydrating: bool);
method take_errors (line 129) | fn take_errors(&self) -> Vec<(SerializedDataId, ErrorId, Error)>;
method errors (line 132) | fn errors(&self, boundary_id: &SerializedDataId) -> Vec<(ErrorId, Erro...
method seal_errors (line 138) | fn seal_errors(&self, boundary_id: &SerializedDataId);
method register_error (line 141) | fn register_error(
method defer_stream (line 154) | fn defer_stream(&self, wait_for: PinnedFuture<()>);
method await_deferred (line 160) | fn await_deferred(&self) -> Option<PinnedFuture<()>>;
method set_incomplete_chunk (line 164) | fn set_incomplete_chunk(&self, id: SerializedDataId);
method get_incomplete_chunk (line 167) | fn get_incomplete_chunk(&self, id: &SerializedDataId) -> bool;
FILE: hydration_context/src/ssr.rs
type AsyncDataBuf (line 22) | type AsyncDataBuf = Arc<RwLock<Vec<(SerializedDataId, PinnedFuture<Strin...
type ErrorBuf (line 23) | type ErrorBuf = Arc<RwLock<Vec<(SerializedDataId, ErrorId, Error)>>>;
type SealedErrors (line 24) | type SealedErrors = Arc<RwLock<HashSet<SerializedDataId>>>;
type SsrSharedContext (line 28) | pub struct SsrSharedContext {
method new (line 42) | pub fn new() -> Self {
method new_islands (line 54) | pub fn new_islands() -> Self {
method consume_buffers (line 68) | pub async fn consume_buffers(&self) -> Vec<(SerializedDataId, String)> {
method fmt (line 85) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
method is_browser (line 96) | fn is_browser(&self) -> bool {
method next_id (line 101) | fn next_id(&self) -> SerializedDataId {
method write_async (line 110) | fn write_async(&self, id: SerializedDataId, fut: PinnedFuture<String>) {
method read_data (line 114) | fn read_data(&self, _id: &SerializedDataId) -> Option<String> {
method await_data (line 118) | fn await_data(&self, _id: &SerializedDataId) -> Option<String> {
method get_is_hydrating (line 122) | fn get_is_hydrating(&self) -> bool {
method set_is_hydrating (line 126) | fn set_is_hydrating(&self, is_hydrating: bool) {
method errors (line 130) | fn errors(&self, boundary_id: &SerializedDataId) -> Vec<(ErrorId, Error)> {
method register_error (line 145) | fn register_error(
method take_errors (line 158) | fn take_errors(&self) -> Vec<(SerializedDataId, ErrorId, Error)> {
method seal_errors (line 162) | fn seal_errors(&self, boundary_id: &SerializedDataId) {
method pending_data (line 169) | fn pending_data(&self) -> Option<PinnedStream<String>> {
method during_hydration (line 227) | fn during_hydration(&self) -> bool {
method hydration_complete (line 231) | fn hydration_complete(&self) {}
method defer_stream (line 233) | fn defer_stream(&self, wait_for: PinnedFuture<()>) {
method await_deferred (line 237) | fn await_deferred(&self) -> Option<PinnedFuture<()>> {
method set_incomplete_chunk (line 248) | fn set_incomplete_chunk(&self, id: SerializedDataId) {
method get_incomplete_chunk (line 252) | fn get_incomplete_chunk(&self, id: &SerializedDataId) -> bool {
type AsyncDataStream (line 261) | struct AsyncDataStream {
type Item (line 268) | type Item = String;
method poll_next (line 270) | fn poll_next(
type ResolvedData (line 318) | struct ResolvedData(SerializedDataId, String);
method write_to_buf (line 321) | pub fn write_to_buf(&self, buf: &mut String) {
FILE: integrations/actix/src/lib.rs
type ResponseParts (line 58) | pub struct ResponseParts {
method insert_header (line 67) | pub fn insert_header(
method append_header (line 76) | pub fn append_header(
type Request (line 88) | pub struct Request(SendWrapper<HttpRequest>);
method new (line 92) | pub fn new(req: &HttpRequest) -> Self {
method into_inner (line 97) | pub fn into_inner(self) -> HttpRequest {
type Target (line 103) | type Target = HttpRequest;
method deref (line 105) | fn deref(&self) -> &Self::Target {
method deref_mut (line 111) | fn deref_mut(&mut self) -> &mut Self::Target {
type ResponseOptions (line 118) | pub struct ResponseOptions(pub Arc<RwLock<ResponseParts>>);
method overwrite (line 122) | pub fn overwrite(&self, parts: ResponseParts) {
method set_status (line 127) | pub fn set_status(&self, status: StatusCode) {
method insert_header (line 133) | pub fn insert_header(
method append_header (line 143) | pub fn append_header(
type ActixResponse (line 154) | struct ActixResponse(HttpResponse);
type ResponseOptions (line 157) | type ResponseOptions = ResponseOptions;
method from_stream (line 159) | fn from_stream(
method extend_response (line 171) | fn extend_response(&mut self, res_options: &Self::ResponseOptions) {
method set_default_content_type (line 185) | fn set_default_content_type(&mut self, content_type: &str) {
function redirect (line 229) | pub fn redirect(path: &str) {
function handle_server_fns (line 312) | pub fn handle_server_fns() -> Route {
function handle_server_fns_with_context (line 339) | pub fn handle_server_fns_with_context(
function render_app_to_stream (line 481) | pub fn render_app_to_stream<IV>(
function render_app_to_stream_in_order (line 544) | pub fn render_app_to_stream_in_order<IV>(
function render_app_async (line 602) | pub fn render_app_async<IV>(
function render_app_to_stream_with_context (line 626) | pub fn render_app_to_stream_with_context<IV>(
function render_app_to_stream_with_context_and_replace_blocks (line 661) | pub fn render_app_to_stream_with_context_and_replace_blocks<IV>(
function render_app_to_stream_in_order_with_context (line 709) | pub fn render_app_to_stream_in_order_with_context<IV>(
function render_app_async_with_context (line 749) | pub fn render_app_async_with_context<IV>(
function async_stream_builder (line 760) | fn async_stream_builder<IV>(
function provide_contexts (line 784) | fn provide_contexts(
function leptos_corrected_path (line 799) | fn leptos_corrected_path(req: &HttpRequest) -> String {
function handle_response (line 810) | fn handle_response<IV>(
function generate_route_list (line 873) | pub fn generate_route_list<IV>(
function generate_route_list_with_ssg (line 885) | pub fn generate_route_list_with_ssg<IV>(
function generate_route_list_with_exclusions (line 898) | pub fn generate_route_list_with_exclusions<IV>(
function generate_route_list_with_exclusions_and_ssg (line 912) | pub fn generate_route_list_with_exclusions_and_ssg<IV>(
type ActixPath (line 926) | trait ActixPath {
method to_actix_path (line 927) | fn to_actix_path(&self) -> String;
method to_actix_path (line 931) | fn to_actix_path(&self) -> String {
type ActixRouteListing (line 968) | pub struct ActixRouteListing {
method new (line 1010) | pub fn new(
method path (line 1026) | pub fn path(&self) -> &str {
method mode (line 1031) | pub fn mode(&self) -> SsrMode {
method methods (line 1036) | pub fn methods(&self) -> impl Iterator<Item = leptos_router::Method> +...
type IntoRouteListing (line 976) | trait IntoRouteListing: Sized {
method into_route_listing (line 977) | fn into_route_listing(self) -> Vec<ActixRouteListing>;
method into_route_listing (line 981) | fn into_route_listing(self) -> Vec<ActixRouteListing> {
function generate_route_list_with_exclusions_and_ssg_and_context (line 1046) | pub fn generate_route_list_with_exclusions_and_ssg_and_context<IV>(
type StaticRouteGenerator (line 1114) | pub struct StaticRouteGenerator(
method render_route (line 1123) | fn render_route<IV: IntoView + 'static>(
method new (line 1170) | pub fn new<IV>(
method generate (line 1220) | pub async fn generate(self, options: &LeptosOptions) {
function was_404 (line 1229) | fn was_404(owner: &Owner) -> bool {
function static_path (line 1240) | fn static_path(options: &LeptosOptions, path: &str) -> String {
function write_static_route (line 1252) | async fn write_static_route(
function handle_static_route (line 1275) | fn handle_static_route<IV>(
type LeptosRoutes (line 1366) | pub trait LeptosRoutes {
method leptos_routes (line 1370) | fn leptos_routes<IV>(
method leptos_routes_with_context (line 1384) | fn leptos_routes_with_context<IV>(
method leptos_routes (line 1409) | fn leptos_routes<IV>(
method leptos_routes_with_context (line 1424) | fn leptos_routes_with_context<IV>(
method leptos_routes (line 1522) | fn leptos_routes<IV>(
method leptos_routes_with_context (line 1537) | fn leptos_routes_with_context<IV>(
function extract (line 1645) | pub async fn extract<T>() -> Result<T, ServerFnErrorErr>
FILE: integrations/axum/src/lib.rs
type ResponseParts (line 97) | pub struct ResponseParts {
method insert_header (line 106) | pub fn insert_header(&mut self, key: HeaderName, value: HeaderValue) {
method append_header (line 110) | pub fn append_header(&mut self, key: HeaderName, value: HeaderValue) {
type ResponseOptions (line 133) | pub struct ResponseOptions(pub Arc<RwLock<ResponseParts>>);
method overwrite (line 137) | pub fn overwrite(&self, parts: ResponseParts) {
method set_status (line 142) | pub fn set_status(&self, status: StatusCode) {
method insert_header (line 148) | pub fn insert_header(&self, key: HeaderName, value: HeaderValue) {
method append_header (line 154) | pub fn append_header(&self, key: HeaderName, value: HeaderValue) {
type AxumResponse (line 161) | struct AxumResponse(Response<Body>);
type ResponseOptions (line 164) | type ResponseOptions = ResponseOptions;
method from_stream (line 166) | fn from_stream(
method extend_response (line 177) | fn extend_response(&mut self, res_options: &Self::ResponseOptions) {
method set_default_content_type (line 187) | fn set_default_content_type(&mut self, content_type: &str) {
function redirect (line 227) | pub fn redirect(path: &str) {
function generate_request_and_parts (line 278) | pub fn generate_request_and_parts(
function handle_server_fns (line 326) | pub async fn handle_server_fns(req: Request<Body>) -> impl IntoResponse {
function init_executor (line 330) | fn init_executor() {
function handle_server_fns_with_context (line 371) | pub async fn handle_server_fns_with_context(
function handle_server_fns_inner (line 378) | async fn handle_server_fns_inner(
type PinnedHtmlStream (line 447) | pub type PinnedHtmlStream =
function render_app_to_stream (line 496) | pub fn render_app_to_stream<IV>(
function render_route (line 519) | pub fn render_route<S, IV>(
function render_app_to_stream_in_order (line 585) | pub fn render_app_to_stream_in_order<IV>(
function render_app_to_stream_with_context (line 638) | pub fn render_app_to_stream_with_context<IV>(
function render_route_with_context (line 667) | pub fn render_route_with_context<S, IV>(
function render_app_to_stream_with_context_and_replace_blocks (line 770) | pub fn render_app_to_stream_with_context_and_replace_blocks<IV>(
function render_app_to_stream_in_order_with_context (line 844) | pub fn render_app_to_stream_in_order_with_context<IV>(
function handle_response (line 868) | fn handle_response<IV>(
function handle_response_inner (line 892) | pub fn handle_response_inner<IV>(
function provide_contexts (line 955) | fn provide_contexts(
function render_app_async (line 1017) | pub fn render_app_async<IV>(
function render_app_async_stream_with_context (line 1071) | pub fn render_app_async_stream_with_context<IV>(
function render_app_async_with_context (line 1138) | pub fn render_app_async_with_context<IV>(
function async_stream_builder (line 1153) | fn async_stream_builder<IV>(
function generate_route_list (line 1180) | pub fn generate_route_list<IV>(
function generate_route_list_with_ssg (line 1196) | pub fn generate_route_list_with_ssg<IV>(
function generate_route_list_with_exclusions (line 1213) | pub fn generate_route_list_with_exclusions<IV>(
function generate_route_list_with_exclusions_and_ssg (line 1231) | pub fn generate_route_list_with_exclusions_and_ssg<IV>(
type AxumRouteListing (line 1247) | pub struct AxumRouteListing {
method new (line 1290) | pub fn new(
method path (line 1306) | pub fn path(&self) -> &str {
method mode (line 1311) | pub fn mode(&self) -> &SsrMode {
method methods (line 1316) | pub fn methods(&self) -> impl Iterator<Item = leptos_router::Method> +...
type IntoRouteListing (line 1256) | trait IntoRouteListing: Sized {
method into_route_listing (line 1257) | fn into_route_listing(self) -> Vec<AxumRouteListing>;
method into_route_listing (line 1261) | fn into_route_listing(self) -> Vec<AxumRouteListing> {
function generate_route_list_with_exclusions_and_ssg_and_context (line 1330) | pub fn generate_route_list_with_exclusions_and_ssg_and_context<IV>(
type StaticRouteGenerator (line 1398) | pub struct StaticRouteGenerator(
method render_route (line 1408) | fn render_route<IV: IntoView + 'static>(
method new (line 1460) | pub fn new<IV>(
method generate (line 1528) | pub async fn generate(self, options: &LeptosOptions) {
function was_404 (line 1539) | fn was_404(owner: &Owner) -> bool {
function static_path (line 1551) | fn static_path(options: &LeptosOptions, path: &str) -> String {
function write_static_route (line 1564) | async fn write_static_route(
function handle_static_route (line 1588) | fn handle_static_route<S, IV>(
type LeptosRoutes (line 1684) | pub trait LeptosRoutes<S>
method leptos_routes (line 1692) | fn leptos_routes<IV>(
method leptos_routes_with_context (line 1707) | fn leptos_routes_with_context<IV>(
method leptos_routes_with_handler (line 1719) | fn leptos_routes_with_handler<H, T>(
type AxumPath (line 1729) | trait AxumPath {
method to_axum_path (line 1730) | fn to_axum_path(&self) -> String;
method to_axum_path (line 1734) | fn to_axum_path(&self) -> String {
function leptos_routes (line 1781) | fn leptos_routes<IV>(
function leptos_routes_with_context (line 1797) | fn leptos_routes_with_context<IV>(
function leptos_routes_with_handler (line 1952) | fn leptos_routes_with_handler<H, T>(
function extract (line 2004) | pub async fn extract<T>() -> Result<T, ServerFnErrorErr>
function extract_with_state (line 2019) | pub async fn extract_with_state<T, S>(state: &S) -> Result<T, ServerFnEr...
function file_and_error_handler_with_context (line 2044) | pub fn file_and_error_handler_with_context<S, IV>(
function file_and_error_handler (line 2133) | pub fn file_and_error_handler<S, IV>(
function get_static_file (line 2152) | async fn get_static_file(
function site_pkg_dir_service (line 2190) | pub fn site_pkg_dir_service(options: &LeptosOptions) -> ServeDir {
function site_pkg_dir_service_route_path (line 2201) | pub fn site_pkg_dir_service_route_path(options: &LeptosOptions) -> String {
FILE: integrations/axum/src/service.rs
type ErrorHandler (line 59) | pub struct ErrorHandler<CX, SH> {
function new (line 67) | pub fn new(shell: SH, options: LeptosOptions) -> Self {
function new_with_context (line 78) | pub fn new_with_context(
type Response (line 96) | type Response = Response<Body>;
type Error (line 97) | type Error = Infallible;
type Future (line 98) | type Future = Pin<
function poll_ready (line 107) | fn poll_ready(
function call (line 114) | fn call(&mut self, req: Request<Body>) -> Self::Future {
type Response (line 127) | type Response = Response<Body>;
type Error (line 128) | type Error = Infallible;
type Future (line 129) | type Future = Pin<
function poll_ready (line 138) | fn poll_ready(
function call (line 145) | fn call(&mut self, req: Request<Body>) -> Self::Future {
function render_error_handler (line 153) | fn render_error_handler<IV>(
FILE: integrations/axum/tests/axum_integration.rs
function bare_no_fallback (line 19) | async fn bare_no_fallback() -> anyhow::Result<()> {
function fallback (line 33) | async fn fallback() -> anyhow::Result<()> {
function fallback_with_context (line 61) | async fn fallback_with_context() -> anyhow::Result<()> {
function error_handler_service (line 86) | async fn error_handler_service() -> anyhow::Result<()> {
function error_handler_service_fallback (line 105) | async fn error_handler_service_fallback() -> anyhow::Result<()> {
function route_site_pkg_no_fallback (line 135) | async fn route_site_pkg_no_fallback() -> anyhow::Result<()> {
function leptos_options_css_base (line 171) | async fn leptos_options_css_base() -> anyhow::Result<()> {
function leptos_options_css_moved (line 186) | async fn leptos_options_css_moved() -> anyhow::Result<()> {
function build_test_service (line 232) | fn build_test_service(name: &str) {
type Service (line 264) | struct Service {
method url (line 270) | fn url(&self, path: &str) -> anyhow::Result<Url> {
function build_services (line 279) | fn build_services() {
function start_test_service (line 285) | async fn start_test_service(name: &str, mode: &str) -> Service {
function start_test_service_with_envs (line 289) | async fn start_test_service_with_envs(
FILE: integrations/axum/tests/service_mode/src/app.rs
function shell (line 8) | pub fn shell(options: LeptosOptions) -> impl IntoView {
function App (line 27) | pub fn App() -> impl IntoView {
function HomePage (line 53) | fn HomePage() -> impl IntoView {
FILE: integrations/axum/tests/service_mode/src/lib.rs
function hydrate (line 5) | pub fn hydrate() {
FILE: integrations/axum/tests/service_mode/src/main.rs
type Cli (line 13) | pub struct Cli {
type Mode (line 19) | enum Mode {
method from (line 31) | fn from(cli: Cli) -> Self {
function main (line 133) | async fn main() {
function main (line 150) | pub fn main() {}
FILE: integrations/utils/src/lib.rs
type PinnedStream (line 16) | pub type PinnedStream<T> = Pin<Box<dyn Stream<Item = T> + Send>>;
type PinnedFuture (line 17) | pub type PinnedFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
type BoxedFnOnce (line 18) | pub type BoxedFnOnce<T> = Box<dyn FnOnce() -> T + Send>;
type ExtendResponse (line 20) | pub trait ExtendResponse: Sized {
method from_stream (line 23) | fn from_stream(stream: impl Stream<Item = String> + Send + 'static)
method extend_response (line 26) | fn extend_response(&mut self, opt: &Self::ResponseOptions);
method set_default_content_type (line 28) | fn set_default_content_type(&mut self, content_type: &str);
method from_app (line 30) | fn from_app<IV>(
function build_response (line 140) | pub fn build_response<IV>(
function static_file_path (line 203) | pub fn static_file_path(options: &LeptosOptions, path: &str) -> String {
FILE: leptos/build.rs
function main (line 3) | fn main() {
FILE: leptos/src/animated_show.rs
function AnimatedShow (line 51) | pub fn AnimatedShow(
FILE: leptos/src/attribute_interceptor.rs
type ChildBuilder (line 8) | type ChildBuilder<T> = dyn Fn(AnyAttribute) -> T + Send + Sync + 'static;
function AttributeInterceptor (line 39) | pub fn AttributeInterceptor<Chil, T>(
type AttributeInterceptorInner (line 53) | struct AttributeInterceptorInner<T: IntoView, A> {
function new (line 62) | pub fn new<F>(children: F) -> Self
type State (line 78) | type State = <T as Render>::State;
method build (line 80) | fn build(self) -> Self::State {
method rebuild (line 84) | fn rebuild(self, state: &mut Self::State) {
type Output (line 93) | type Output<SomeNewAttr: leptos::attr::Attribute> =
method add_any_attr (line 96) | fn add_any_attr<NewAttr: leptos::attr::Attribute>(
type AsyncOutput (line 120) | type AsyncOutput = T::AsyncOutput;
type Owned (line 121) | type Owned = AttributeInterceptorInner<T, A::CloneableOwned>;
constant MIN_LENGTH (line 123) | const MIN_LENGTH: usize = T::MIN_LENGTH;
method dry_resolve (line 125) | fn dry_resolve(&mut self) {
method resolve (line 129) | fn resolve(
method to_html_with_buf (line 135) | fn to_html_with_buf(
method hydrate (line 152) | fn hydrate<const FROM_SERVER: bool>(
method hydrate_async (line 160) | async fn hydrate_async(
method into_owned (line 168) | fn into_owned(self) -> Self::Owned {
FILE: leptos/src/await_.rs
function Await (line 34) | pub fn Await<T, Fut, Chil, V>(
FILE: leptos/src/children.rs
type Children (line 17) | pub type Children = Box<dyn FnOnce() -> AnyView + Send>;
method to_children (line 103) | fn to_children(f: F) -> Self {
method to_children (line 113) | fn to_children(t: ChildrenOptContainer<T>) -> Self {
type ChildrenFragment (line 21) | pub type ChildrenFragment = Box<dyn FnOnce() -> Fragment + Send>;
method to_children (line 187) | fn to_children(f: F) -> Self {
method to_children (line 197) | fn to_children(t: ChildrenOptContainer<T>) -> Self {
type ChildrenFn (line 25) | pub type ChildrenFn = Arc<dyn Fn() -> AnyView + Send + Sync>;
method to_children (line 124) | fn to_children(f: F) -> Self {
method to_children (line 134) | fn to_children(t: ChildrenOptContainer<T>) -> Self {
type ChildrenFragmentFn (line 29) | pub type ChildrenFragmentFn = Arc<dyn Fn() -> Fragment + Send>;
method to_children (line 208) | fn to_children(f: F) -> Self {
method to_children (line 218) | fn to_children(t: ChildrenOptContainer<T>) -> Self {
type ChildrenFnMut (line 33) | pub type ChildrenFnMut = Box<dyn FnMut() -> AnyView + Send>;
method to_children (line 145) | fn to_children(f: F) -> Self {
method to_children (line 155) | fn to_children(t: ChildrenOptContainer<T>) -> Self {
type ChildrenFragmentMut (line 38) | pub type ChildrenFragmentMut = Box<dyn FnMut() -> Fragment + Send>;
method to_children (line 229) | fn to_children(mut f: F) -> Self {
method to_children (line 239) | fn to_children(t: ChildrenOptContainer<T>) -> Self {
type BoxedChildrenFn (line 41) | type BoxedChildrenFn = Box<dyn Fn() -> AnyView + Send>;
method to_children (line 166) | fn to_children(f: F) -> Self {
method to_children (line 176) | fn to_children(t: ChildrenOptContainer<T>) -> Self {
type ToChildren (line 87) | pub trait ToChildren<F> {
method to_children (line 91) | fn to_children(f: F) -> Self;
type ChildrenOptContainer (line 95) | pub struct ChildrenOptContainer<T>(pub T);
type ViewFn (line 247) | pub struct ViewFn(Arc<dyn Fn() -> AnyView + Send + Sync + 'static>);
method from (line 260) | fn from(value: F) -> Self {
method from (line 270) | fn from(value: View<C>) -> Self {
method run (line 277) | pub fn run(&self) -> AnyView {
method default (line 250) | fn default() -> Self {
type ViewFnOnce (line 284) | pub struct ViewFnOnce(Box<dyn FnOnce() -> AnyView + Send + 'static>);
method from (line 297) | fn from(value: F) -> Self {
method from (line 307) | fn from(value: View<C>) -> Self {
method run (line 314) | pub fn run(self) -> AnyView {
method default (line 287) | fn default() -> Self {
type TypedChildren (line 321) | pub struct TypedChildren<T>(Box<dyn FnOnce() -> View<T> + Send>);
function into_inner (line 325) | pub fn into_inner(self) -> impl FnOnce() -> View<T> + Send {
function to_children (line 337) | fn to_children(f: F) -> Self {
function to_children (line 347) | fn to_children(t: ChildrenOptContainer<T>) -> Self {
type TypedChildrenMut (line 354) | pub struct TypedChildrenMut<T>(Box<dyn FnMut() -> View<T> + Send>);
method fmt (line 357) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
function into_inner (line 364) | pub fn into_inner(self) -> impl FnMut() -> View<T> + Send {
function to_children (line 376) | fn to_children(mut f: F) -> Self {
function to_children (line 386) | fn to_children(t: ChildrenOptContainer<T>) -> Self {
type TypedChildrenFn (line 393) | pub struct TypedChildrenFn<T>(Arc<dyn Fn() -> View<T> + Send + Sync>);
method fmt (line 396) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
method clone (line 403) | fn clone(&self) -> Self {
function into_inner (line 410) | pub fn into_inner(self) -> Arc<dyn Fn() -> View<T> + Send + Sync> {
function to_children (line 422) | fn to_children(f: F) -> Self {
function to_children (line 432) | fn to_children(t: ChildrenOptContainer<T>) -> Self {
FILE: leptos/src/component.rs
type Component (line 5) | pub trait Component<P> {}
type Props (line 7) | pub trait Props {
method builder (line 10) | fn builder() -> Self::Builder;
type PropsOrNoPropsBuilder (line 14) | pub trait PropsOrNoPropsBuilder {
method builder_or_not (line 17) | fn builder_or_not() -> Self::Builder;
type Builder (line 29) | type Builder = <P as Props>::Builder;
method builder_or_not (line 31) | fn builder_or_not() -> Self::Builder {
type Builder (line 37) | type Builder = EmptyPropsBuilder;
method builder_or_not (line 39) | fn builder_or_not() -> Self::Builder {
type EmptyPropsBuilder (line 22) | pub struct EmptyPropsBuilder {}
method build (line 25) | pub fn build(self) {}
function component_props_builder (line 53) | pub fn component_props_builder<P: PropsOrNoPropsBuilder>(
function component_view (line 59) | pub fn component_view<P, T>(f: impl ComponentConstructor<P, T>, props: P...
type ComponentConstructor (line 62) | pub trait ComponentConstructor<P, T> {
method construct (line 63) | fn construct(self, props: P) -> T;
method construct (line 70) | fn construct(self, (): ()) -> T {
method construct (line 80) | fn construct(self, props: P) -> T {
FILE: leptos/src/error_boundary.rs
function ErrorBoundary (line 78) | pub fn ErrorBoundary<FalFn, Fal, Chil>(
type ErrorBoundarySuspendedChildren (line 129) | pub(crate) type ErrorBoundarySuspendedChildren =
type ErrorBoundaryView (line 132) | struct ErrorBoundaryView<Chil, FalFn> {
type ErrorBoundaryViewState (line 142) | struct ErrorBoundaryViewState<Chil, Fal> {
method unmount (line 153) | fn unmount(&mut self) {
method mount (line 161) | fn mount(
method insert_before_this (line 173) | fn insert_before_this(&self, child: &mut dyn Mountable) -> bool {
method elements (line 181) | fn elements(&self) -> Vec<tachys::renderer::types::Element> {
type State (line 196) | type State = RenderEffect<ErrorBoundaryViewState<Chil::State, Fal::State>>;
method build (line 198) | fn build(mut self) -> Self::State {
method rebuild (line 243) | fn rebuild(self, state: &mut Self::State) {
type Output (line 257) | type Output<SomeNewAttr: Attribute> =
method add_any_attr (line 260) | fn add_any_attr<NewAttr: Attribute>(
type AsyncOutput (line 294) | type AsyncOutput = ErrorBoundaryView<Chil::AsyncOutput, FalFn>;
type Owned (line 295) | type Owned = Self;
constant MIN_LENGTH (line 297) | const MIN_LENGTH: usize = Chil::MIN_LENGTH;
method dry_resolve (line 299) | fn dry_resolve(&mut self) {
method resolve (line 303) | async fn resolve(self) -> Self::AsyncOutput {
method to_html_with_buf (line 325) | fn to_html_with_buf(
method to_html_async_with_buf (line 360) | fn to_html_async_with_buf<const OUT_OF_ORDER: bool>(
method hydrate (line 456) | fn hydrate<const FROM_SERVER: bool>(
method hydrate_async (line 517) | async fn hydrate_async(
method into_owned (line 590) | fn into_owned(self) -> Self::Owned {
type ErrorBoundaryErrorHook (line 596) | struct ErrorBoundaryErrorHook {
method new (line 603) | pub fn new(
method throw (line 618) | fn throw(&self, error: Error) -> ErrorId {
method clear (line 641) | fn clear(&self, id: &throw_error::ErrorId) {
type Errors (line 651) | pub struct Errors(FxHashMap<ErrorId, Error>);
method is_empty (line 656) | pub fn is_empty(&self) -> bool {
method insert (line 661) | pub fn insert<E>(&mut self, key: ErrorId, error: E)
method insert_with_default_key (line 669) | pub fn insert_with_default_key<E>(&mut self, error: E)
method remove (line 677) | pub fn remove(&mut self, key: &ErrorId) -> Option<Error> {
method iter (line 683) | pub fn iter(&self) -> Iter<'_> {
type Item (line 689) | type Item = (ErrorId, Error);
type IntoIter (line 690) | type IntoIter = IntoIter;
method into_iter (line 693) | fn into_iter(self) -> Self::IntoIter {
type IntoIter (line 700) | pub struct IntoIter(std::collections::hash_map::IntoIter<ErrorId, Error>);
type Item (line 703) | type Item = (ErrorId, Error);
method next (line 706) | fn next(
type Iter (line 715) | pub struct Iter<'a>(std::collections::hash_map::Iter<'a, ErrorId, Error>);
type Item (line 718) | type Item = (&'a ErrorId, &'a Error);
method next (line 721) | fn next(
FILE: leptos/src/for_loop.rs
function For (line 113) | pub fn For<IF, I, T, EF, N, KF, K>(
function ForEnumerate (line 187) | pub fn ForEnumerate<IF, I, T, EF, N, KF, K>(
FILE: leptos/src/form.rs
function ActionForm (line 78) | pub fn ActionForm<ServFn, OutputProtocol>(
function MultiActionForm (line 155) | pub fn MultiActionForm<ServFn, OutputProtocol>(
function resolve_redirect_url (line 219) | pub(crate) fn resolve_redirect_url(loc: &str) -> Option<web_sys::Url> {
type FromFormData (line 245) | pub trait FromFormData
method from_event (line 250) | fn from_event(ev: &web_sys::Event) -> Result<Self, FromFormDataError>;
method from_form_data (line 253) | fn from_form_data(
method from_event (line 276) | fn from_event(ev: &Event) -> Result<Self, FromFormDataError> {
method from_form_data (line 283) | fn from_form_data(
type FromFormDataError (line 260) | pub enum FromFormDataError {
function form_data_from_event (line 294) | fn form_data_from_event(
FILE: leptos/src/hydration/island_script.js
function idle (line 4) | function idle(c) {
function hydrateIslands (line 11) | async function hydrateIslands(rootNode, mod) {
function hydrateIsland (line 43) | async function hydrateIsland(el, id, mod) {
FILE: leptos/src/hydration/islands_routing.js
constant NAVIGATION (line 1) | let NAVIGATION = 0;
function navigateToPage (line 33) | async function navigateToPage(
function clickToReq (line 84) | function clickToReq(ev) {
function submitToReq (line 122) | function submitToReq(ev) {
function diffPages (line 170) | function diffPages(htmlString) {
function diffRange (line 178) | function diffRange(oldDocument, oldRoot, newDocument, newRoot, oldEnd, n...
function replaceFor (line 234) | function replaceFor(oldDocument, oldDocWalker, newDocument, newDocWalker...
function replaceBranch (line 326) | function replaceBranch(oldDocWalker, newDocWalker, oldNode, newNode) {
function diffElement (line 373) | function diffElement(oldNode, newNode) {
FILE: leptos/src/hydration/mod.rs
function AutoReload (line 12) | pub fn AutoReload(
function HydrationScripts (line 48) | pub fn HydrationScripts(
type IslandsRouterNavigation (line 203) | pub struct IslandsRouterNavigation;
FILE: leptos/src/hydration/reload_script.js
function connect (line 7) | function connect() {
FILE: leptos/src/into_view.rs
type View (line 14) | pub struct View<T>
function new (line 25) | pub fn new(inner: T) -> Self {
function into_inner (line 34) | pub fn into_inner(self) -> T {
function with_view_marker (line 40) | pub fn with_view_marker(
type IntoView (line 55) | pub trait IntoView
method into_view (line 60) | fn into_view(self) -> View<Self>;
method into_view (line 67) | fn into_view(self) -> View<Self> {
type State (line 77) | type State = T::State;
method build (line 79) | fn build(self) -> Self::State {
method rebuild (line 83) | fn rebuild(self, state: &mut Self::State) {
type AsyncOutput (line 89) | type AsyncOutput = T::AsyncOutput;
type Owned (line 90) | type Owned = View<T::Owned>;
constant MIN_LENGTH (line 92) | const MIN_LENGTH: usize = <T as RenderHtml>::MIN_LENGTH;
constant EXISTS (line 93) | const EXISTS: bool = <T as RenderHtml>::EXISTS;
method resolve (line 95) | async fn resolve(self) -> Self::AsyncOutput {
method dry_resolve (line 99) | fn dry_resolve(&mut self) {
method to_html_with_buf (line 103) | fn to_html_with_buf(
method to_html_async_with_buf (line 137) | fn to_html_async_with_buf<const OUT_OF_ORDER: bool>(
method hydrate (line 173) | fn hydrate<const FROM_SERVER: bool>(
method hydrate_async (line 181) | async fn hydrate_async(
method into_owned (line 189) | fn into_owned(self) -> Self::Owned {
method to_template (line 199) | fn to_template(
type Output (line 211) | type Output<SomeNewAttr: Attribute> = View<T::Output<SomeNewAttr>>;
method add_any_attr (line 213) | fn add_any_attr<NewAttr: Attribute>(
type CollectView (line 237) | pub trait CollectView {
method collect_view (line 242) | fn collect_view(self) -> Vec<Self::View>;
type View (line 250) | type View = V;
method collect_view (line 252) | fn collect_view(self) -> Vec<Self::View> {
FILE: leptos/src/lib.rs
function spawn (line 330) | pub fn spawn(fut: impl Future<Output = ()> + Send + 'static) {
function spawn_local (line 343) | pub fn spawn_local(fut: impl Future<Output = ()> + 'static) {
function tick (line 348) | pub async fn tick() {
type PrefetchLazyFn (line 381) | pub struct PrefetchLazyFn(
function prefetch_lazy_fn_on_server (line 388) | pub fn prefetch_lazy_fn_on_server(id: &'static str) {
type WasmSplitManifest (line 399) | pub struct WasmSplitManifest(
FILE: leptos/src/logging.rs
function log_to_stdout (line 44) | const fn log_to_stdout() -> bool {
function console_log (line 53) | pub fn console_log(s: &str) {
function console_warn (line 64) | pub fn console_warn(s: &str) {
function console_error (line 75) | pub fn console_error(s: &str) {
function console_debug_warn (line 86) | pub fn console_debug_warn(s: &str) {
FILE: leptos/src/mount.rs
function hydrate_body (line 23) | pub fn hydrate_body<F, N>(f: F)
function hydrate_lazy (line 35) | pub fn hydrate_lazy<F, N>(f: F)
function hydrate_from (line 58) | pub fn hydrate_from<F, N>(parent: HtmlElement, f: F) -> UnmountHandle<N:...
function hydrate_from_async (line 107) | pub async fn hydrate_from_async<F, N>(
function mount_to_body (line 165) | pub fn mount_to_body<F, N>(f: F)
function mount_to (line 175) | pub fn mount_to<F, N>(parent: HtmlElement, f: F) -> UnmountHandle<N::State>
function mount_to_renderer (line 216) | pub fn mount_to_renderer<F, N>(
function hydrate_islands (line 245) | pub fn hydrate_islands() {
type UnmountHandle (line 274) | pub struct UnmountHandle<M>
function forget (line 290) | pub fn forget(self) {
method drop (line 299) | fn drop(&mut self) {
FILE: leptos/src/nonce.rs
type Nonce (line 52) | pub struct Nonce(pub(crate) Arc<str>);
method as_inner (line 56) | pub fn as_inner(&self) -> &Arc<str> {
method new (line 173) | pub fn new() -> Self {
type Target (line 62) | type Target = str;
method deref (line 64) | fn deref(&self) -> &Self::Target {
method fmt (line 70) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
type AsyncOutput (line 76) | type AsyncOutput = Self;
type State (line 77) | type State = <Arc<str> as AttributeValue>::State;
type Cloneable (line 78) | type Cloneable = Self;
type CloneableOwned (line 79) | type CloneableOwned = Self;
method html_len (line 81) | fn html_len(&self) -> usize {
method to_html (line 85) | fn to_html(self, key: &str, buf: &mut String) {
method to_template (line 89) | fn to_template(_key: &str, _buf: &mut String) {}
method hydrate (line 91) | fn hydrate<const FROM_SERVER: bool>(
method build (line 99) | fn build(
method rebuild (line 107) | fn rebuild(self, key: &str, state: &mut Self::State) {
method into_cloneable (line 111) | fn into_cloneable(self) -> Self::Cloneable {
method into_cloneable_owned (line 115) | fn into_cloneable_owned(self) -> Self::CloneableOwned {
method dry_resolve (line 119) | fn dry_resolve(&mut self) {}
method resolve (line 121) | async fn resolve(self) -> Self::AsyncOutput {
function use_nonce (line 159) | pub fn use_nonce() -> Option<Nonce> {
function provide_nonce (line 164) | pub fn provide_nonce() {
constant NONCE_ENGINE (line 168) | const NONCE_ENGINE: engine::GeneralPurpose =
method default (line 182) | fn default() -> Self {
FILE: leptos/src/portal.rs
function Portal (line 15) | pub fn Portal<V>(
FILE: leptos/src/provider.rs
function Provider (line 31) | pub fn Provider<T, Chil>(
FILE: leptos/src/show.rs
function Show (line 10) | pub fn Show<W, C>(
FILE: leptos/src/show_let.rs
function ShowLet (line 76) | pub fn ShowLet<T, ChFn, V, M>(
type OptionGetter (line 117) | pub struct OptionGetter<T>(Arc<dyn Fn() -> Option<T> + Send + Sync + 'st...
method clone (line 120) | fn clone(&self) -> Self {
function run (line 127) | pub fn run(&self) -> Option<T> {
type IntoOptionGetter (line 133) | pub trait IntoOptionGetter<T, M> {
method into_option_getter (line 135) | fn into_option_getter(self) -> OptionGetter<T>;
type FunctionMarker (line 140) | pub struct FunctionMarker;
method into_option_getter (line 146) | fn into_option_getter(self) -> OptionGetter<T> {
type SignalMarker (line 157) | pub struct SignalMarker;
method into_option_getter (line 164) | fn into_option_getter(self) -> OptionGetter<T> {
type StaticMarker (line 172) | pub struct StaticMarker;
function into_option_getter (line 178) | fn into_option_getter(self) -> OptionGetter<T> {
FILE: leptos/src/subsecond.rs
function connect_to_hot_patch_messages (line 13) | pub fn connect_to_hot_patch_messages() {
FILE: leptos/src/suspense_component.rs
function Suspense (line 95) | pub fn Suspense<Chil>(
function nonce_or_not (line 150) | fn nonce_or_not() -> Option<Arc<str>> {
type SuspenseBoundary (line 162) | pub(crate) struct SuspenseBoundary<const TRANSITION: bool, Fal, Chil> {
type State (line 177) | type State = RenderEffect<
method build (line 181) | fn build(self) -> Self::State {
method rebuild (line 228) | fn rebuild(self, state: &mut Self::State) {
type Output (line 242) | type Output<SomeNewAttr: Attribute> = SuspenseBoundary<
method add_any_attr (line 248) | fn add_any_attr<NewAttr: Attribute>(
type AsyncOutput (line 283) | type AsyncOutput = Self;
type Owned (line 284) | type Owned = Self;
constant MIN_LENGTH (line 286) | const MIN_LENGTH: usize = Chil::MIN_LENGTH;
method dry_resolve (line 288) | fn dry_resolve(&mut self) {}
method resolve (line 290) | async fn resolve(self) -> Self::AsyncOutput {
method to_html_with_buf (line 294) | fn to_html_with_buf(
method to_html_async_with_buf (line 311) | fn to_html_async_with_buf<const OUT_OF_ORDER: bool>(
method hydrate (line 537) | fn hydrate<const FROM_SERVER: bool>(
method into_owned (line 577) | fn into_owned(self) -> Self::Owned {
type Unsuspend (line 584) | pub struct Unsuspend<T>(Box<dyn FnOnce() -> T + Send>);
function new (line 588) | pub fn new(fun: impl FnOnce() -> T + Send + 'static) -> Self {
type State (line 597) | type State = T::State;
method build (line 599) | fn build(self) -> Self::State {
method rebuild (line 603) | fn rebuild(self, state: &mut Self::State) {
type Output (line 612) | type Output<SomeNewAttr: Attribute> =
method add_any_attr (line 615) | fn add_any_attr<NewAttr: Attribute>(
type AsyncOutput (line 631) | type AsyncOutput = Self;
type Owned (line 632) | type Owned = Self;
constant MIN_LENGTH (line 634) | const MIN_LENGTH: usize = T::MIN_LENGTH;
method dry_resolve (line 636) | fn dry_resolve(&mut self) {}
method resolve (line 638) | async fn resolve(self) -> Self::AsyncOutput {
method to_html_with_buf (line 642) | fn to_html_with_buf(
method to_html_async_with_buf (line 659) | fn to_html_async_with_buf<const OUT_OF_ORDER: bool>(
method hydrate (line 678) | fn hydrate<const FROM_SERVER: bool>(
method into_owned (line 686) | fn into_owned(self) -> Self::Owned {
FILE: leptos/src/text_prop.rs
type TextProp (line 8) | pub struct TextProp(Arc<dyn Fn() -> Oco<'static, str> + Send + Sync>);
method get (line 13) | pub fn get(&self) -> Oco<'static, str> {
method fmt (line 19) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method from (line 25) | fn from(s: String) -> Self {
method from (line 32) | fn from(s: &'static str) -> Self {
method from (line 39) | fn from(s: Arc<str>) -> Self {
method from (line 46) | fn from(s: Oco<'static, str>) -> Self {
method from (line 67) | fn from(s: F) -> Self {
method default (line 73) | fn default() -> Self {
type Output (line 79) | type Output = Arc<dyn Fn() -> Oco<'static, str> + Send + Sync>;
method into_attribute_value (line 81) | fn into_attribute_value(self) -> Self::Output {
type OptionTextPropExt (line 166) | pub trait OptionTextPropExt {
method get (line 168) | fn get(&self) -> Option<Oco<'static, str>>;
method get (line 172) | fn get(&self) -> Option<Oco<'static, str>> {
FILE: leptos/src/transition.rs
function Transition (line 76) | pub fn Transition<Chil>(
FILE: leptos/tests/pr_4061.rs
function chain_await_resource (line 10) | async fn chain_await_resource() {
function chain_no_await_resource (line 50) | async fn chain_no_await_resource() {
FILE: leptos/tests/ssr.rs
function simple_ssr_test (line 6) | fn simple_ssr_test() {
function ssr_test_with_components (line 27) | fn ssr_test_with_components() {
function ssr_test_with_snake_case_components (line 59) | fn ssr_test_with_snake_case_components() {
function test_classes (line 90) | fn test_classes() {
function test_class_with_class_directive_merge (line 108) | fn test_class_with_class_directive_merge() {
function test_solo_class_directive (line 121) | fn test_solo_class_directive() {
function test_class_directive_with_static_class (line 134) | fn test_class_directive_with_static_class() {
function test_global_class_applied (line 150) | fn test_global_class_applied() {
function test_multiple_class_attributes_overwrite (line 163) | fn test_multiple_class_attributes_overwrite() {
function ssr_with_styles (line 178) | fn ssr_with_styles() {
function ssr_option (line 200) | fn ssr_option() {
FILE: leptos_config/src/errors.rs
type LeptosConfigError (line 5) | pub enum LeptosConfigError {
method from (line 18) | fn from(e: config::ConfigError) -> Self {
method from (line 24) | fn from(e: ParseIntError) -> Self {
method from (line 30) | fn from(e: AddrParseError) -> Self {
method from (line 36) | fn from(e: ParseBoolError) -> Self {
FILE: leptos_config/src/lib.rs
type ConfFile (line 23) | pub struct ConfFile {
type LeptosOptions (line 34) | pub struct LeptosOptions {
method css_file_path (line 160) | pub fn css_file_path(&self) -> PathBuf {
method css_path (line 178) | pub fn css_path(&self) -> String {
method site_pkg_dir_route_base (line 186) | pub fn site_pkg_dir_route_base(&self) -> String {
method try_from_env (line 199) | fn try_from_env() -> Result<Self, LeptosConfigError> {
function default_site_root (line 246) | fn default_site_root() -> Arc<str> {
function default_site_pkg_dir (line 250) | fn default_site_pkg_dir() -> Arc<str> {
function default_env (line 254) | fn default_env() -> Env {
function default_site_addr (line 258) | fn default_site_addr() -> SocketAddr {
function default_reload_port (line 262) | fn default_reload_port() -> u32 {
function default_not_found_path (line 266) | fn default_not_found_path() -> Arc<str> {
function default_hash_file_name (line 270) | fn default_hash_file_name() -> Arc<str> {
function default_hash_files (line 274) | fn default_hash_files() -> bool {
function env_wo_default (line 278) | fn env_wo_default(key: &str) -> Result<Option<String>, LeptosConfigError> {
function env_w_default (line 285) | fn env_w_default(
constant ENV_DEV_KEY_SHORT (line 296) | pub const ENV_DEV_KEY_SHORT: &str = "dev";
constant ENV_DEV_KEY_LONG (line 297) | pub const ENV_DEV_KEY_LONG: &str = "development";
constant ENV_PROD_KEY_SHORT (line 298) | pub const ENV_PROD_KEY_SHORT: &str = "prod";
constant ENV_PROD_KEY_LONG (line 299) | pub const ENV_PROD_KEY_LONG: &str = "production";
type Env (line 305) | pub enum Env {
method from (line 332) | fn from(str: &str) -> Self {
method from (line 338) | fn from(input: &Result<String, VarError>) -> Self {
type Error (line 349) | type Error = LeptosConfigError;
method try_from (line 351) | fn try_from(s: String) -> Result<Self, Self::Error> {
method deserialize (line 383) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
function env_from_str (line 311) | fn env_from_str(input: &str) -> Result<Env, LeptosConfigError> {
type Err (line 325) | type Err = ();
method from_str (line 326) | fn from_str(input: &str) -> Result<Self, Self::Err> {
type EnvVisitor (line 357) | struct EnvVisitor;
type Value (line 360) | type Value = Env;
method expecting (line 362) | fn expecting(
method visit_str (line 374) | fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
type ReloadWSProtocol (line 396) | pub enum ReloadWSProtocol {
method from (line 422) | fn from(str: &str) -> Self {
method from (line 428) | fn from(input: &Result<String, VarError>) -> Self {
type Error (line 437) | type Error = LeptosConfigError;
method try_from (line 439) | fn try_from(s: String) -> Result<Self, Self::Error> {
function ws_from_str (line 402) | fn ws_from_str(input: &str) -> Result<ReloadWSProtocol, LeptosConfigErro...
type Err (line 415) | type Err = ();
method from_str (line 416) | fn from_str(input: &str) -> Result<Self, Self::Err> {
function get_config_from_str (line 452) | pub fn get_config_from_str(
function get_configuration (line 506) | pub fn get_configuration(
function get_config_from_file (line 526) | pub fn get_config_from_file<P: AsRef<Path>>(
function get_config_from_env (line 540) | pub fn get_config_from_env() -> Result<ConfFile, LeptosConfigError> {
FILE: leptos_config/src/tests.rs
function env_from_str_test (line 8) | fn env_from_str_test() {
function ws_from_str_test (line 22) | fn ws_from_str_test() {
function env_w_default_test (line 32) | fn env_w_default_test() {
function env_wo_default_test (line 49) | fn env_wo_default_test() {
function try_from_env_test (line 63) | fn try_from_env_test() {
function leptos_options_css_file_path (line 93) | fn leptos_options_css_file_path() {
function leptos_options_css_path (line 131) | fn leptos_options_css_path() {
FILE: leptos_config/tests/config.rs
function env_default (line 9) | fn env_default() {
constant CARGO_TOML_CONTENT_OK (line 13) | const CARGO_TOML_CONTENT_OK: &str = r#"\
constant CARGO_TOML_CONTENT_ERR (line 24) | const CARGO_TOML_CONTENT_ERR: &str = r#"\
function get_configuration_from_file_ok (line 30) | async fn get_configuration_from_file_ok() {
function get_configuration_from_invalid_file (line 65) | async fn get_configuration_from_invalid_file() {
function get_configuration_from_empty_file (line 77) | async fn get_configuration_from_empty_file() {
function get_config_from_file_ok (line 89) | async fn get_config_from_file_ok() {
function get_config_from_file_invalid (line 121) | async fn get_config_from_file_invalid() {
function get_config_from_file_empty (line 131) | async fn get_config_from_file_empty() {
function get_config_from_str_content (line 141) | fn get_config_from_str_content() {
function get_configuration_from_env (line 166) | async fn get_configuration_from_env() {
function leptos_options_builder_default (line 216) | fn leptos_options_builder_default() {
function environment_variable_override (line 231) | fn environment_variable_override() {
function env_consistent_deserialization (line 281) | fn env_consistent_deserialization() {
FILE: leptos_dom/examples/hydration-test/src/lib.rs
function App (line 6) | pub fn App() -> impl IntoView {
function ComponentA (line 36) | pub fn ComponentA() -> impl IntoView {
function hydrate (line 62) | pub fn hydrate() {
FILE: leptos_dom/examples/hydration-test/src/main.rs
function main (line 8) | async fn main() -> std::io::Result<()> {
FILE: leptos_dom/examples/test-bench/src/main.rs
function main (line 11) | fn main() {
function view_fn (line 29) | fn view_fn() -> impl IntoView {
function Test (line 63) | fn Test<From, To>(
FILE: leptos_dom/examples/view-tests/src/main.rs
function main (line 3) | pub fn main() {
function SelfUpdatingEffect (line 10) | fn SelfUpdatingEffect() -> Element {
function Tests (line 25) | fn Tests() -> Element {
function BlockOrders (line 37) | fn BlockOrders() -> Element {
function A (line 91) | fn A() -> Element {
function B (line 96) | fn B() -> Element {
function C (line 101) | fn C() -> Element {
function TemplateConsumer (line 106) | fn TemplateConsumer() -> Element {
function TemplateExample (line 124) | fn TemplateExample() -> Element {
FILE: leptos_dom/src/helpers.rs
function window (line 24) | pub fn window() -> web_sys::Window {
function document (line 32) | pub fn document() -> web_sys::Document {
function set_property (line 37) | pub fn set_property(
function get_property (line 51) | pub fn get_property(
function location (line 60) | pub fn location() -> web_sys::Location {
function location_hash (line 66) | pub fn location_hash() -> Option<String> {
function location_pathname (line 81) | pub fn location_pathname() -> Option<String> {
function event_target (line 87) | pub fn event_target<T>(event: &web_sys::Event) -> T
function event_target_value (line 97) | pub fn event_target_value<T>(event: &T) -> String
function event_target_checked (line 112) | pub fn event_target_checked(ev: &web_sys::Event) -> bool {
type AnimationFrameRequestHandle (line 122) | pub struct AnimationFrameRequestHandle(i32);
method cancel (line 127) | pub fn cancel(&self) {
function request_animation_frame (line 140) | pub fn request_animation_frame(cb: impl FnOnce() + 'static) {
function closure_once (line 153) | fn closure_once(cb: impl FnOnce() + 'static) -> JsValue {
function request_animation_frame_with_handle (line 172) | pub fn request_animation_frame_with_handle(
type IdleCallbackHandle (line 196) | pub struct IdleCallbackHandle(u32);
method cancel (line 201) | pub fn cancel(&self) {
function request_idle_callback (line 214) | pub fn request_idle_callback(cb: impl Fn() + 'static) {
function request_idle_callback_with_handle (line 227) | pub fn request_idle_callback_with_handle(
function queue_microtask (line 260) | pub fn queue_microtask(task: impl FnOnce() + 'static) {
type TimeoutHandle (line 266) | pub struct TimeoutHandle(i32);
method clear (line 271) | pub fn clear(&self) {
function set_timeout (line 286) | pub fn set_timeout(cb: impl FnOnce() + 'static, duration: Duration) {
function set_timeout_with_handle (line 301) | pub fn set_timeout_with_handle(
function debounce (line 356) | pub fn debounce<T: 'static>(
type IntervalHandle (line 411) | pub struct IntervalHandle(i32);
method clear (line 416) | pub fn clear(&self) {
function set_interval (line 431) | pub fn set_interval(cb: impl Fn() + 'static, duration: Duration) {
function set_interval_with_handle (line 447) | pub fn set_interval_with_handle(
function window_event_listener_untyped (line 493) | pub fn window_event_listener_untyped(
function window_event_listener (line 560) | pub fn window_event_listener<E: EventDescriptor + 'static>(
type WindowListenerHandle (line 573) | pub struct WindowListenerHandle(Box<dyn FnOnce() + Send + Sync>);
method fmt (line 576) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method remove (line 583) | pub fn remove(self) {
function is_server (line 589) | pub fn is_server() -> bool {
function is_browser (line 603) | pub fn is_browser() -> bool {
FILE: leptos_dom/src/logging.rs
function log_to_stdout (line 65) | const fn log_to_stdout() -> bool {
function console_log (line 74) | pub fn console_log(s: &str) {
function console_warn (line 85) | pub fn console_warn(s: &str) {
function console_error (line 96) | pub fn console_error(s: &str) {
function console_debug_log (line 107) | pub fn console_debug_log(s: &str) {
function console_debug_warn (line 116) | pub fn console_debug_warn(s: &str) {
function console_debug_error (line 125) | pub fn console_debug_error(s: &str) {
FILE: leptos_dom/src/macro_helpers/tracing_property.rs
type Match (line 38) | pub struct Match<T> {
type SerializeMatch (line 43) | pub trait SerializeMatch {
method spez (line 45) | fn spez(&self) -> Self::Return;
type Return (line 48) | type Return = String;
method spez (line 49) | fn spez(&self) -> Self::Return {
type DefaultMatch (line 63) | pub trait DefaultMatch {
method spez (line 65) | fn spez(&self) -> Self::Return;
type Return (line 68) | type Return = String;
method spez (line 69) | fn spez(&self) -> Self::Return {
function match_primitive (line 76) | fn match_primitive() {
function match_serialize (line 133) | fn match_serialize() {
function match_no_serialize (line 153) | fn match_no_serialize() {
FILE: leptos_hot_reload/src/diff.rs
type OldChildren (line 6) | struct OldChildren(IndexMap<LNode, Vec<usize>>);
method diff (line 10) | pub fn diff(&self, other: &LNode) -> Vec<Patch> {
method to_replacement_node (line 16) | fn to_replacement_node(
method add_old_children (line 64) | fn add_old_children(&self, path: Vec<usize>, positions: &mut OldChildren) {
method diff_at (line 98) | fn diff_at(
method diff_attrs (line 183) | fn diff_attrs<'a>(
method diff_children (line 230) | fn diff_children(
type Patches (line 325) | pub struct Patches(pub Vec<(String, Vec<Patch>)>);
type Patch (line 328) | pub struct Patch {
type PatchAction (line 334) | pub enum PatchAction {
type ReplacementNode (line 356) | pub enum ReplacementNode {
function patches_text (line 376) | fn patches_text() {
function patches_attrs (line 390) | fn patches_attrs() {
function patches_child_text (line 434) | fn patches_child_text() {
function inserts_child (line 462) | fn inserts_child() {
function removes_child (line 506) | fn removes_child() {
FILE: leptos_hot_reload/src/lib.rs
constant HOT_RELOAD_JS (line 27) | pub const HOT_RELOAD_JS: &str = include_str!("patch.js");
type ViewMacros (line 30) | pub struct ViewMacros {
method new (line 37) | pub fn new() -> Self {
method update_from_paths (line 44) | pub fn update_from_paths<T: AsRef<Path>>(&self, paths: &[T]) -> Result...
method parse_file (line 69) | pub fn parse_file(path: &Utf8PathBuf) -> Result<Vec<MacroInvocation>> {
method patch (line 102) | pub fn patch(&self, path: &Utf8PathBuf) -> Result<Option<Patches>> {
type MacroInvocation (line 141) | pub struct MacroInvocation {
method fmt (line 147) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
type ViewMacroVisitor (line 155) | pub struct ViewMacroVisitor<'a> {
function visit_macro (line 160) | fn visit_macro(&mut self, node: &'ast Macro) {
function span_to_stable_id (line 171) | pub fn span_to_stable_id(path: impl AsRef<Path>, line: usize) -> String {
FILE: leptos_hot_reload/src/node.rs
type LNode (line 14) | pub enum LNode {
method parse_view (line 45) | pub fn parse_view(nodes: Vec<Node>) -> Result<LNode> {
method parse_node (line 62) | pub fn parse_node(node: Node, views: &mut Vec<LNode>) -> Result<()> {
method to_html (line 138) | pub fn to_html(&self) -> String {
type LAttributeValue (line 33) | pub enum LAttributeValue {
FILE: leptos_hot_reload/src/parsing.rs
function block_to_primitive_expression (line 17) | pub fn block_to_primitive_expression(block: &syn::Block) -> Option<&syn:...
function value_to_string (line 33) | pub fn value_to_string(value: &syn::Expr) -> Option<String> {
function is_component_tag_name (line 50) | pub fn is_component_tag_name(name: &NodeName) -> bool {
function is_component_node (line 68) | pub fn is_component_node(node: &NodeElement<impl CustomNode>) -> bool {
FILE: leptos_hot_reload/src/patch.js
function patch (line 2) | function patch(json) {
FILE: leptos_macro/build.rs
function main (line 3) | fn main() {
FILE: leptos_macro/example/src/lib.rs
function TestComponent (line 4) | pub fn TestComponent(
function TestMutCallback (line 41) | pub fn TestMutCallback<F>(mut callback: F, value: &'static str) -> impl ...
FILE: leptos_macro/src/component.rs
type Model (line 21) | pub struct Model {
method is_transparent (line 637) | pub fn is_transparent(mut self, is_transparent: bool) -> Self {
method is_lazy (line 644) | pub fn is_lazy(mut self, is_lazy: bool) -> Self {
method with_island (line 651) | pub fn with_island(mut self, island: Option<String>) -> Self {
method parse (line 35) | fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
function maybe_modify_return_type (line 86) | fn maybe_modify_return_type(ret: &mut ReturnType) {
function drain_filter (line 119) | pub fn drain_filter<T>(
function convert_from_snake_case (line 133) | pub fn convert_from_snake_case(name: &Ident) -> Ident {
method to_tokens (line 143) | fn to_tokens(&self, tokens: &mut TokenStream) {
type DummyModel (line 662) | pub struct DummyModel {
method parse (line 670) | fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
method to_tokens (line 695) | fn to_tokens(&self, tokens: &mut TokenStream) {
type Prop (line 739) | struct Prop {
method new (line 747) | fn new(arg: FnArg) -> Self {
type Docs (line 810) | pub struct Docs(Vec<(String, Span)>);
method new (line 825) | pub fn new(attrs: &[Attribute]) -> Self {
method padded (line 927) | pub fn padded(&self) -> TokenStream {
method typed_builder (line 945) | pub fn typed_builder(&self) -> String {
method to_tokens (line 813) | fn to_tokens(&self, tokens: &mut TokenStream) {
function is_lint_attr (line 956) | fn is_lint_attr(attr: &Attribute) -> bool {
type UnknownAttrs (line 965) | pub struct UnknownAttrs(Vec<(TokenStream, Span)>);
method new (line 968) | pub fn new(attrs: &[Attribute]) -> Self {
method to_tokens (line 990) | fn to_tokens(&self, tokens: &mut TokenStream) {
type PropOpt (line 1002) | struct PropOpt {
type TypedBuilderOpts (line 1016) | struct TypedBuilderOpts<'a> {
function from_opts (line 1025) | fn from_opts(opts: &PropOpt, ty: &'a Type) -> Self {
function to_serde_tokens (line 1037) | fn to_serde_tokens(&self) -> TokenStream {
method to_tokens (line 1056) | fn to_tokens(&self, tokens: &mut TokenStream) {
function prop_builder_fields (line 1109) | fn prop_builder_fields(
function prop_serializer_fields (line 1155) | fn prop_serializer_fields(vis: &Visibility, props: &[Prop]) -> TokenStre...
function prop_names (line 1184) | fn prop_names(props: &[Prop]) -> TokenStream {
function generate_component_fn_prop_docs (line 1196) | fn generate_component_fn_prop_docs(props: &[Prop]) -> TokenStream {
function is_option (line 1241) | pub fn is_option(ty: &Type) -> bool {
function unwrap_option (line 1257) | pub fn unwrap_option(ty: &Type) -> Type {
type PropDocStyle (line 1291) | enum PropDocStyle {
function prop_to_doc (line 1296) | fn prop_to_doc(
function unmodified_fn_name_from_fn_name (line 1374) | pub fn unmodified_fn_name_from_fn_name(ident: &Ident) -> Ident {
function convert_impl_trait_to_generic (line 1382) | fn convert_impl_trait_to_generic(sig: &mut Signature) {
FILE: leptos_macro/src/lazy.rs
function lazy_impl (line 12) | pub fn lazy_impl(args: proc_macro::TokenStream, s: TokenStream) -> Token...
FILE: leptos_macro/src/lib.rs
function view (line 272) | pub fn view(tokens: TokenStream) -> TokenStream {
function template (line 283) | pub fn template(tokens: TokenStream) -> TokenStream {
function view_macro_impl (line 291) | fn view_macro_impl(tokens: TokenStream, template: bool) -> TokenStream {
function normalized_call_site (line 360) | fn normalized_call_site(site: proc_macro::Span) -> Option<String> {
function include_view (line 381) | pub fn include_view(tokens: TokenStream) -> TokenStream {
function component (line 562) | pub fn component(args: proc_macro::TokenStream, s: TokenStream) -> Token...
function island (line 655) | pub fn island(args: proc_macro::TokenStream, s: TokenStream) -> TokenStr...
function component_macro (line 676) | fn component_macro(
function slot (line 825) | pub fn slot(args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
function server (line 947) | pub fn server(args: proc_macro::TokenStream, s: TokenStream) -> TokenStr...
function params_derive (line 964) | pub fn params_derive(
function slice (line 1001) | pub fn slice(input: TokenStream) -> TokenStream {
function memo (line 1033) | pub fn memo(input: TokenStream) -> TokenStream {
function lazy (line 1074) | pub fn lazy(args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
FILE: leptos_macro/src/memo.rs
type MemoMacroInput (line 12) | struct MemoMacroInput {
method parse (line 18) | fn parse(input: ParseStream) -> syn::Result<Self> {
method to_tokens (line 38) | fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
function memo_impl (line 53) | pub fn memo_impl(tokens: TokenStream) -> TokenStream {
FILE: leptos_macro/src/params.rs
function params_impl (line 4) | pub fn params_impl(ast: &syn::DeriveInput) -> proc_macro::TokenStream {
FILE: leptos_macro/src/slice.rs
type SliceMacroInput (line 12) | struct SliceMacroInput {
method parse (line 18) | fn parse(input: ParseStream) -> syn::Result<Self> {
method to_tokens (line 38) | fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
function slice_impl (line 52) | pub fn slice_impl(tokens: TokenStream) -> TokenStream {
FILE: leptos_macro/src/slot.rs
type Model (line 12) | pub struct Model {
method parse (line 21) | fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
method to_tokens (line 59) | fn to_tokens(&self, tokens: &mut TokenStream) {
type Prop (line 113) | struct Prop {
method new (line 121) | fn new(arg: Field) -> Self {
type PropOpt (line 149) | struct PropOpt {
type TypedBuilderOpts (line 162) | struct TypedBuilderOpts<'a> {
function from_opts (line 171) | pub fn from_opts(opts: &PropOpt, ty: &'a Type) -> Self {
method to_tokens (line 183) | fn to_tokens(&self, tokens: &mut TokenStream) {
function prop_builder_fields (line 236) | fn prop_builder_fields(vis: &Visibility, props: &[Prop]) -> TokenStream {
function generate_prop_docs (line 261) | fn generate_prop_docs(props: &[Prop]) -> TokenStream {
type PropDocStyle (line 303) | enum PropDocStyle {
function prop_to_doc (line 308) | fn prop_to_doc(
FILE: leptos_macro/src/view/component_builder.rs
function component_to_tokens (line 18) | pub(crate) fn component_to_tokens(
function is_attr_let (line 322) | fn is_attr_let(key: &NodeName) -> bool {
function items_to_clone_to_tokens (line 332) | pub fn items_to_clone_to_tokens(
function maybe_optimised_component_children (line 344) | pub fn maybe_optimised_component_children(
FILE: leptos_macro/src/view/mod.rs
type TagType (line 34) | pub(crate) enum TagType {
function render_view (line 41) | pub fn render_view(
function is_inert_element (line 108) | fn is_inert_element(orig_node: &Node<impl CustomNode>) -> bool {
type Item (line 191) | enum Item<'a, T> {
type InertElementBuilder (line 196) | enum InertElementBuilder<'a> {
method to_tokens (line 208) | fn to_tokens(&self, tokens: &mut TokenStream) {
type GlobalClassItem (line 224) | enum GlobalClassItem<'a> {
method to_tokens (line 230) | fn to_tokens(&self, tokens: &mut TokenStream) {
function new (line 240) | fn new(global_class: Option<&'a TokenTree>) -> Self {
function push (line 253) | fn push(&mut self, c: char) {
function push_str (line 260) | fn push_str(&mut self, s: &str) {
function push_class (line 269) | fn push_class(&mut self, class: &str) {
function finish (line 291) | fn finish(&mut self) {
function inert_element_to_tokens (line 301) | fn inert_element_to_tokens(
function inert_svg_element_to_tokens (line 409) | fn inert_svg_element_to_tokens(
function element_children_to_tokens (line 520) | fn element_children_to_tokens(
function fragment_to_tokens (line 579) | fn fragment_to_tokens(
function children_to_tokens (line 626) | fn children_to_tokens(
function node_to_tokens (line 676) | fn node_to_tokens(
function text_to_tokens (line 742) | fn text_to_tokens(text: &LitStr) -> TokenStream {
function element_to_tokens (line 755) | pub(crate) fn element_to_tokens(
function is_spread_marker (line 1028) | fn is_spread_marker(node: &NodeElement<impl CustomNode>) -> bool {
function as_spread_attr (line 1046) | fn as_spread_attr(node: &NodeBlock) -> Option<Option<&Expr>> {
function attribute_to_tokens (line 1065) | fn attribute_to_tokens(
function attribute_absolute (line 1170) | pub(crate) fn attribute_absolute(
function two_way_binding_to_tokens (line 1306) | pub(crate) fn two_way_binding_to_tokens(
function event_to_tokens (line 1326) | pub(crate) fn event_to_tokens(
function event_type_and_handler (line 1337) | pub(crate) fn event_type_and_handler(
function class_to_tokens (line 1412) | fn class_to_tokens(
function style_to_tokens (line 1455) | fn style_to_tokens(
function prop_to_tokens (line 1472) | fn prop_to_tokens(
function is_custom_element (line 1483) | fn is_custom_element(tag: &str) -> bool {
function is_self_closing (line 1487) | fn is_self_closing(node: &NodeElement<impl CustomNode>) -> bool {
function is_svg_element (line 1498) | fn is_svg_element(tag: &str) -> bool {
function is_math_ml_element (line 1569) | fn is_math_ml_element(tag: &str) -> bool {
function is_ambiguous_element (line 1608) | fn is_ambiguous_element(tag: &str) -> bool {
function parse_event (line 1612) | fn parse_event(event_name: &str) -> (String, EventNameOptions) {
function attribute_name (line 1632) | fn attribute_name(name: &NodeName) -> TokenStream {
function attribute_value (line 1643) | fn attribute_value(
constant TYPED_EVENTS (line 1688) | const TYPED_EVENTS: [&str; 127] = [
constant CUSTOM_EVENT (line 1818) | const CUSTOM_EVENT: &str = "Custom";
type EventNameOptions (line 1821) | pub(crate) struct EventNameOptions {
function parse_event_name (line 1827) | pub(crate) fn parse_event_name(
function convert_to_snake_case (line 1849) | fn convert_to_snake_case(name: String) -> String {
function ident_from_tag_name (line 1857) | pub(crate) fn ident_from_tag_name(tag_name: &NodeName) -> Ident {
function full_path_from_tag_name (line 1881) | pub(crate) fn full_path_from_tag_name(tag_name: &NodeName) -> Option<Exp...
function directive_call_from_attribute_node (line 1903) | pub(crate) fn directive_call_from_attribute_node(
function tuple_name (line 1918) | fn tuple_name(name: &str, node: &KeyedAttribute) -> TupleName {
type TupleName (line 1957) | enum TupleName {
FILE: leptos_macro/src/view/slot_helper.rs
function slot_to_tokens (line 12) | pub(crate) fn slot_to_tokens(
function is_slot (line 214) | pub(crate) fn is_slot(node: &KeyedAttribute) -> bool {
function get_slot (line 220) | pub(crate) fn get_slot(
FILE: leptos_macro/src/view/utils.rs
function filter_prefixed_attrs (line 6) | pub fn filter_prefixed_attrs<'a, A>(attrs: A, prefix: &str) -> Vec<Ident>
function is_nostrip_optional_and_update_key (line 25) | pub fn is_nostrip_optional_and_update_key(key: &mut NodeName) -> bool {
FILE: leptos_macro/tests/component.rs
type UserInfo (line 5) | struct UserInfo {
type Admin (line 11) | struct Admin(bool);
function Component (line 14) | fn Component(
function component (line 43) | fn component() {
function component_nostrip (line 76) | fn component_nostrip() {
function WithLifetime (line 109) | fn WithLifetime<'a>(data: &'a str) -> impl IntoView {
function returns_static_lifetime (line 115) | fn returns_static_lifetime() {
function IntoReactiveValueTestComponentSignal (line 125) | pub fn IntoReactiveValueTestComponentSignal(
function IntoReactiveValueTestComponentCallback (line 173) | pub fn IntoReactiveValueTestComponentCallback(
function test_into_reactive_value_signal (line 201) | fn test_into_reactive_value_signal() {
function test_into_reactive_value_callback (line 226) | fn test_into_reactive_value_callback() {
function view (line 249) | fn view() {
function view_into_any (line 264) | fn view_into_any() {
FILE: leptos_macro/tests/memo.rs
type OuterState (line 5) | pub struct OuterState {
type InnerState (line 11) | pub struct InnerState {
type InnerTuple (line 17) | pub struct InnerTuple(String);
function green (line 20) | fn green() {
function red (line 30) | fn red() {
FILE: leptos_macro/tests/memo/red.rs
type OuterState (line 5) | pub struct OuterState {
type InnerState (line 11) | pub struct InnerState {
function main (line 16) | fn main() {
FILE: leptos_macro/tests/params.rs
type UserInfo (line 5) | struct UserInfo {
function params_test (line 13) | fn params_test() {
FILE: leptos_macro/tests/server.rs
function server_default (line 10) | fn server_default() {
function server_full_legacy (line 27) | fn server_full_legacy() {
function server_all_keywords (line 40) | fn server_all_keywords() {
function server_mix (line 53) | fn server_mix() {
function server_name (line 66) | fn server_name() {
function server_prefix (line 82) | fn server_prefix() {
function server_encoding (line 99) | fn server_encoding() {
function server_endpoint (line 116) | fn server_endpoint() {
FILE: leptos_macro/tests/slice.rs
type OuterState (line 5) | pub struct OuterState {
type InnerState (line 11) | pub struct InnerState {
type InnerTuple (line 17) | pub struct InnerTuple(String);
function green (line 20) | fn green() {
function red (line 30) | fn red() {
FILE: leptos_macro/tests/slice/red.rs
type OuterState (line 5) | pub struct OuterState {
type InnerState (line 11) | pub struct InnerState {
function main (line 16) | fn main() {
FILE: leptos_macro/tests/ui.rs
function ui (line 3) | fn ui() {
FILE: leptos_macro/tests/ui/component.rs
function missing_scope (line 5) | fn missing_scope() {}
function missing_return_type (line 9) | fn missing_return_type() {}
function unknown_prop_option (line 13) | fn unknown_prop_option(#[prop(hello)] test: bool) -> impl IntoView {
function optional_and_optional_no_strip (line 19) | fn optional_and_optional_no_strip(
function optional_and_strip_option (line 27) | fn optional_and_strip_option(
function optional_no_strip_and_strip_option (line 35) | fn optional_no_strip_and_strip_option(
function default_without_value (line 43) | fn default_without_value(#[prop(default)] default: bool) -> impl IntoView {
function default_with_invalid_value (line 49) | fn default_with_invalid_value(
function destructure_without_name (line 57) | fn destructure_without_name((default, value): (bool, i32)) -> impl IntoV...
function main (line 62) | fn main() {}
FILE: leptos_macro/tests/ui/component_absolute.rs
function missing_return_type (line 3) | fn missing_return_type() {}
function unknown_prop_option (line 7) | fn unknown_prop_option(#[prop(hello)] test: bool) -> impl ::leptos::Into...
function optional_and_optional_no_strip (line 13) | fn optional_and_optional_no_strip(
function optional_and_strip_option (line 21) | fn optional_and_strip_option(
function optional_no_strip_and_strip_option (line 29) | fn optional_no_strip_and_strip_option(
function default_without_value (line 37) | fn default_without_value(
function default_with_invalid_value (line 45) | fn default_with_invalid_value(
function using_the_view_macro (line 53) | pub fn using_the_view_macro() -> impl ::leptos::IntoView {
function main (line 57) | fn main() {}
FILE: leptos_macro/tests/ui/server.rs
function positional_argument_follows_keyword_argument (line 4) | pub async fn positional_argument_follows_keyword_argument(
function keyword_argument_repeated (line 10) | pub async fn keyword_argument_repeated() -> Result<(), ServerFnError> {
function expected_string_literal (line 15) | pub async fn expected_string_literal() -> Result<(), ServerFnError> {
function expected_string_literal_2 (line 19) | pub async fn expected_string_literal_2() -> Result<(), ServerFnError> {
function expected_identifier (line 24) | pub async fn expected_identifier() -> Result<(), ServerFnError> {
function expected_comma (line 29) | pub async fn expected_comma() -> Result<(), ServerFnError> {
function unexpected_extra_argument (line 34) | pub async fn unexpected_extra_argument() -> Result<(), ServerFnError> {
function encoding_not_found (line 39) | pub async fn encoding_not_found() -> Result<(), ServerFnError> {
function main (line 43) | fn main() {}
FILE: leptos_server/src/action.rs
type ServerActionError (line 17) | pub struct ServerActionError {
method new (line 24) | pub fn new(path: &str, err: &str) -> Self {
method path (line 32) | pub fn path(&self) -> &str {
method err (line 37) | pub fn err(&self) -> &str {
type ArcServerAction (line 43) | pub struct ArcServerAction<S>
function new (line 62) | pub fn new() -> Self {
type Target (line 83) | type Target = ArcAction<S, Result<S::Output, S::Error>>;
method deref (line 85) | fn deref(&self) -> &Self::Target {
method clone (line 95) | fn clone(&self) -> Self {
method default (line 110) | fn default() -> Self {
method defined_at (line 120) | fn defined_at(&self) -> Option<&'static Location<'static>> {
type ServerAction (line 133) | pub struct ServerAction<S>
function new (line 150) | pub fn new() -> Self {
method clone (line 171) | fn clone(&self) -> Self {
type Target (line 189) | type Target = Action<S, Result<S::Output, S::Error>>;
method deref (line 191) | fn deref(&self) -> &Self::Target {
function from (line 201) | fn from(value: ServerAction<S>) -> Self {
method default (line 212) | fn default() -> Self {
method defined_at (line 222) | fn defined_at(&self) -> Option<&'static Location<'static>> {
FILE: leptos_server/src/lib.rs
type IntoEncodedString (line 25) | pub trait IntoEncodedString {
method into_encoded_string (line 27) | fn into_encoded_string(self) -> String;
method into_encoded_string (line 45) | fn into_encoded_string(self) -> String {
method into_encoded_string (line 62) | fn into_encoded_string(self) -> String {
type FromEncodedStr (line 31) | pub trait FromEncodedStr {
method from_encoded_str (line 39) | fn from_encoded_str(
type DecodedType (line 51) | type DecodedType<'a> = &'a str;
type DecodingError (line 52) | type DecodingError = ();
method from_encoded_str (line 54) | fn from_encoded_str(
type DecodedType (line 68) | type DecodedType<'a> = Vec<u8>;
type DecodingError (line 69) | type DecodingError = DecodeError;
method from_encoded_str (line 71) | fn from_encoded_str(
type State (line 98) | type State = RenderEffectState<SuspendState<T>>;
method build (line 100) | fn build(self) -> Self::State {
method rebuild (line 104) | fn rebuild(self, state: &mut Self::State) {
type Output (line 114) | type Output<SomeNewAttr: Attribute> = Box<
method add_any_attr (line 123) | fn add_any_attr<NewAttr: Attribute>(
type AsyncOutput (line 139) | type AsyncOutput = Option<T>;
type Owned (line 140) | type Owned = Self;
constant MIN_LENGTH (line 142) | const MIN_LENGTH: usize = 0;
method dry_resolve (line 144) | fn dry_resolve(&mut self) {
method resolve (line 148) | fn resolve(self) -> impl Future<Output = Self::AsyncOutput> + Send {
method to_html_with_buf (line 152) | fn to_html_with_buf(
method to_html_async_with_buf (line 169) | fn to_html_async_with_buf<const OUT_OF_ORDER: bool>(
method hydrate (line 189) | fn hydrate<const FROM_SERVER: bool>(
method into_owned (line 198) | fn into_owned(self) -> Self::Owned {
FILE: leptos_server/src/local_resource.rs
type ArcLocalResource (line 28) | pub struct ArcLocalResource<T> {
method clone (line 36) | fn clone(&self) -> Self {
type Target (line 47) | type Target = ArcAsyncDerived<T>;
method deref (line 49) | fn deref(&self) -> &Self::Target {
function new (line 60) | pub fn new<Fut>(fetcher: impl Fn() -> Fut + 'static) -> Self
function refetch (line 103) | pub fn refetch(&self) {
function map (line 110) | pub fn map<U>(&self, f: impl FnOnce(&T) -> U) -> Option<U>
function and_then (line 131) | pub fn and_then<U>(&self, f: impl FnOnce(&T) -> U) -> Option<Result<U, E...
type Output (line 140) | type Output = T;
type IntoFuture (line 141) | type IntoFuture = AsyncDerivedFuture<T>;
method into_future (line 143) | fn into_future(self) -> Self::IntoFuture {
method defined_at (line 158) | fn defined_at(&self) -> Option<&'static Location<'static>> {
method notify (line 174) | fn notify(&self) {
type Value (line 183) | type Value = Option<T>;
method try_write (line 185) | fn try_write(&self) -> Option<impl UntrackableGuard<Target = Self::Value...
method try_write_untracked (line 189) | fn try_write_untracked(
type Value (line 200) | type Value =
method try_read_untracked (line 203) | fn try_read_untracked(&self) -> Option<Self::Value> {
method is_disposed (line 213) | fn is_disposed(&self) -> bool {
method to_any_source (line 219) | fn to_any_source(&self) -> AnySource {
method to_any_subscriber (line 225) | fn to_any_subscriber(&self) -> AnySubscriber {
method add_subscriber (line 231) | fn add_subscriber(&self, subscriber: AnySubscriber) {
method remove_subscriber (line 235) | fn remove_subscriber(&self, subscriber: &AnySubscriber) {
method clear_subscribers (line 239) | fn clear_subscribers(&self) {
method mark_dirty (line 245) | fn mark_dirty(&self) {
method mark_check (line 249) | fn mark_check(&self) {
method mark_subscribers_check (line 253) | fn mark_subscribers_check(&self) {
method update_if_necessary (line 257) | fn update_if_necessary(&self) -> bool {
method add_source (line 263) | fn add_source(&self, source: AnySource) {
method clear_sources (line 267) | fn clear_sources(&self, subscriber: &AnySubscriber) {
type LocalResource (line 273) | pub struct LocalResource<T> {
type Target (line 281) | type Target = AsyncDerived<T>;
method deref (line 283) | fn deref(&self) -> &Self::Target {
method clone (line 289) | fn clone(&self) -> Self {
function new (line 302) | pub fn new<Fut>(fetcher: impl Fn() -> Fut + 'static) -> Self
function refetch (line 344) | pub fn refetch(&self) {
function map (line 351) | pub fn map<U>(&self, f: impl FnOnce(&T) -> U) -> Option<U>
function and_then (line 372) | pub fn and_then<U>(&self, f: impl FnOnce(&T) -> U) -> Option<Result<U, E...
type Output (line 381) | type Output = T;
type IntoFuture (line 382) | type IntoFuture = AsyncDerivedFuture<T>;
method into_future (line 384) | fn into_future(self) -> Self::IntoFuture {
method defined_at (line 399) | fn defined_at(&self) -> Option<&'static Location<'static>> {
method notify (line 415) | fn notify(&self) {
type Value (line 424) | type Value = Option<T>;
method try_write (line 426) | fn try_write(&self) -> Option<impl UntrackableGuard<Target = Self::Value...
method try_write_untracked (line 430) | fn try_write_untracked(
type Value (line 441) | type Value =
method try_read_untracked (line 444) | fn try_read_untracked(&self) -> Option<Self::Value> {
method is_disposed (line 453) | fn is_disposed(&self) -> bool {
method to_any_source (line 462) | fn to_any_source(&self) -> AnySource {
method to_any_subscriber (line 471) | fn to_any_subscriber(&self) -> AnySubscriber {
method add_subscriber (line 480) | fn add_subscriber(&self, subscriber: AnySubscriber) {
method remove_subscriber (line 484) | fn remove_subscriber(&self, subscriber: &AnySubscriber) {
method clear_subscribers (line 488) | fn clear_subscribers(&self) {
method mark_dirty (line 497) | fn mark_dirty(&self) {
method mark_check (line 501) | fn mark_check(&self) {
method mark_subscribers_check (line 505) | fn mark_subscribers_check(&self) {
method update_if_necessary (line 509) | fn update_if_necessary(&self) -> bool {
method add_source (line 518) | fn add_source(&self, source: AnySource) {
method clear_sources (line 522) | fn clear_sources(&self, subscriber: &AnySubscriber) {
function from (line 528) | fn from(arc: ArcLocalResource<T>) -> Self {
function from (line 539) | fn from(local: LocalResource<T>) -> Self {
FILE: leptos_server/src/multi_action.rs
type ArcServerMultiAction (line 9) | pub struct ArcServerMultiAction<S>
function new (line 27) | pub fn new() -> Self {
type Target (line 43) | type Target = ArcMultiAction<S, Result<S::Output, S::Error>>;
method deref (line 45) | fn deref(&self) -> &Self::Target {
method clone (line 55) | fn clone(&self) -> Self {
method default (line 70) | fn default() -> Self {
method defined_at (line 80) | fn defined_at(&self) -> Option<&'static Location<'static>> {
type ServerMultiAction (line 93) | pub struct ServerMultiAction<S>
function from (line 109) | fn from(value: ServerMultiAction<S>) -> Self {
function new (line 121) | pub fn new() -> Self {
method clone (line 137) | fn clone(&self) -> Self {
type Target (line 155) | type Target = MultiAction<S, Result<S::Output, S::Error>>;
method deref (line 157) | fn deref(&self) -> &Self::Target {
method default (line 168) | fn default() -> Self {
method defined_at (line 178) | fn defined_at(&self) -> Option<&'static Location<'static>> {
FILE: leptos_server/src/once_resource.rs
type ArcOnceResource (line 56) | pub struct ArcOnceResource<T, Ser = JsonSerdeCodec> {
method clone (line 68) | fn clone(&self) -> Self {
function new_with_options (line 99) | pub fn new_with_options(
function map (line 175) | pub fn map<U>(&self, f: impl FnOnce(&T) -> U) -> Option<U>
function and_then (line 203) | pub fn and_then<U>(&self, f: impl FnOnce(&T) -> U) -> Option<Result<U, E...
function ready (line 210) | pub fn ready(&self) -> AsyncDerivedReadyFuture {
method defined_at (line 220) | fn defined_at(&self) -> Option<&'static Location<'static>> {
method is_disposed (line 234) | fn is_disposed(&self) -> bool {
method to_any_source (line 240) | fn to_any_source(&self) -> AnySource {
method track (line 246) | fn track(&self) {
type Value (line 255) | type Value = ReadGuard<Option<T>, Plain<Option<T>>>;
method try_read_untracked (line 257) | fn try_read_untracked(&self) -> Option<Self::Value> {
type Output (line 283) | type Output = T;
type IntoFuture (line 284) | type IntoFuture = OnceResourceFuture<T>;
method into_future (line 286) | fn into_future(self) -> Self::IntoFuture {
type OnceResourceFuture (line 300) | pub struct OnceResourceFuture<T> {
type Output (line 312) | type Output = T;
method poll (line 315) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
function new (line 349) | pub fn new(fut: impl Future<Output = T> + Send + 'static) -> Self {
function new_blocking (line 359) | pub fn new_blocking(fut: impl Future<Output = T> + Send + 'static) -> Se...
function new_str (line 374) | pub fn new_str(
function new_str_blocking (line 386) | pub fn new_str_blocking(
function new_serde_wb (line 407) | pub fn new_serde_wb(
function new_serde_wb_blocking (line 420) | pub fn new_serde_wb_blocking(
function new_miniserde (line 442) | pub fn new_miniserde(
function new_miniserde_blocking (line 454) | pub fn new_miniserde_blocking(
function new_serde_lite (line 474) | pub fn new_serde_lite(
function new_serde_lite_blocking (line 487) | pub fn new_serde_lite_blocking(
function new_rkyv (line 510) | pub fn new_rkyv(fut: impl Future<Output = T> + Send + 'static) -> Self {
function new_rkyv_blocking (line 520) | pub fn new_rkyv_blocking(
type OnceResource (line 537) | pub struct OnceResource<T, Ser = JsonSerdeCodec> {
method clone (line 544) | fn clone(&self) -> Self {
function new_with_options (line 568) | pub fn new_with_options(
function map (line 585) | pub fn map<U>(&self, f: impl FnOnce(&T) -> U) -> Option<U> {
function and_then (line 610) | pub fn and_then<U>(&self, f: impl FnOnce(&T) -> U) -> Option<Result<U, E...
function ready (line 621) | pub fn ready(&self) -> AsyncDerivedReadyFuture {
method defined_at (line 629) | fn defined_at(&self) -> Option<&'static Location<'static>> {
method is_disposed (line 643) | fn is_disposed(&self) -> bool {
method to_any_source (line 653) | fn to_any_source(&self) -> AnySource {
method track (line 665) | fn track(&self) {
type Value (line 677) | type Value = ReadGuard<Option<T>, Plain<Option<T>>>;
method try_read_untracked (line 679) | fn try_read_untracked(&self) -> Option<Self::Value> {
type Output (line 691) | type Output = T;
type IntoFuture (line 692) | type IntoFuture = OnceResourceFuture<T>;
method into_future (line 694) | fn into_future(self) -> Self::IntoFuture {
function new (line 715) | pub fn new(fut: impl Future<Output = T> + Send + 'static) -> Self {
function new_blocking (line 725) | pub fn new_blocking(fut: impl Future<Output = T> + Send + 'static) -> Se...
function new_str (line 740) | pub fn new_str(
function new_str_blocking (line 752) | pub fn new_str_blocking(
function new_serde_wb (line 773) | pub fn new_serde_wb(
function new_serde_wb_blocking (line 786) | pub fn new_serde_wb_blocking(
function new_miniserde (line 808) | pub fn new_miniserde(
function new_miniserde_blocking (line 820) | pub fn new_miniserde_blocking(
function new_serde_lite (line 840) | pub fn new_serde_lite(
function new_serde_lite_blocking (line 853) | pub fn new_serde_lite_blocking(
function new_rkyv (line 876) | pub fn new_rkyv(fut: impl Future<Output = T> + Send + 'static) -> Self {
function new_rkyv_blocking (line 886) | pub fn new_rkyv_blocking(
FILE: leptos_server/src/resource.rs
type SuppressResourceLoad (line 42) | pub struct SuppressResourceLoad;
method new (line 46) | pub fn new() -> Self {
method default (line 53) | fn default() -> Self {
method drop (line 59) | fn drop(&mut self) {
type ArcResource (line 73) | pub struct ArcResource<T, Ser = JsonSerdeCodec> {
method fmt (line 82) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
function from (line 96) | fn from(arc_resource: ArcResource<T, Ser>) -> Self {
function from (line 112) | fn from(resource: Resource<T, Ser>) -> Self {
method defined_at (line 124) | fn defined_at(&self) -> Option<&'static Location<'static>> {
method clone (line 137) | fn clone(&self) -> Self {
type Target (line 149) | type Target = ArcAsyncDerived<T>;
method deref (line 151) | fn deref(&self) -> &Self::Target {
method track (line 160) | fn track(&self) {
method notify (line 169) | fn notify(&self) {
type Value (line 178) | type Value = Option<T>;
method try_write (line 180) | fn try_write(&self) -> Option<impl UntrackableGuard<Target = Self::Value...
method try_write_untracked (line 184) | fn try_write_untracked(
function in_resource_source_signal (line 198) | pub fn in_resource_source_signal() -> bool {
function run_in_resource_source_signal (line 205) | fn run_in_resource_source_signal<T>(fun: impl FnOnce() -> T) -> T {
type Value (line 228) | type Value = <ArcAsyncDerived<T> as ReadUntracked>::Value;
method try_read_untracked (line 231) | fn try_read_untracked(&self) -> Option<Self::Value> {
function new_with_options (line 286) | pub fn new_with_options<S, Fut>(
function map (line 372) | pub fn map<U>(&self, f: impl FnOnce(&T) -> U) -> Option<U>
function refetch (line 380) | pub fn refetch(&self) {
function initial_value (line 387) | pub(crate) fn initial_value<T, Ser>(
function and_then (line 452) | pub fn and_then<U>(&self, f: impl FnOnce(&T) -> U) -> Option<Result<U, E...
function new (line 477) | pub fn new<S, Fut>(
function new_blocking (line 503) | pub fn new_blocking<S, Fut>(
function new_str (line 533) | pub fn new_str<S, Fut>(
function new_str_blocking (line 558) | pub fn new_str_blocking<S, Fut>(
function new_serde_wb (line 590) | pub fn new_serde_wb<S, Fut>(
function new_serde_wb_blocking (line 616) | pub fn new_serde_wb_blocking<S, Fut>(
function new_miniserde (line 649) | pub fn new_miniserde<S, Fut>(
function new_miniserde_blocking (line 675) | pub fn new_miniserde_blocking<S, Fut>(
function new_serde_lite (line 707) | pub fn new_serde_lite<S, Fut>(
function new_serde_lite_blocking (line 733) | pub fn new_serde_lite_blocking<S, Fut>(
function new_rkyv (line 768) | pub fn new_rkyv<S, Fut>(
function new_rkyv_blocking (line 794) | pub fn new_rkyv_blocking<S, Fut>(
type Output (line 811) | type Output = T;
type IntoFuture (line 812) | type IntoFuture = AsyncDerivedFuture<T>;
method into_future (line 814) | fn into_future(self) -> Self::IntoFuture {
function by_ref (line 825) | pub fn by_ref(&self) -> AsyncDerivedRefFuture<T> {
type Resource (line 839) | pub struct Resource<T, Ser = JsonSerdeCodec>
method fmt (line 854) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
method defined_at (line 867) | fn defined_at(&self) -> Option<&'static Location<'static>> {
method clone (line 882) | fn clone(&self) -> Self {
type Target (line 891) | type Target = AsyncDerived<T>;
method deref (line 893) | fn deref(&self) -> &Self::Target {
method track (line 902) | fn track(&self) {
method notify (line 911) | fn notify(&self) {
type Value (line 920) | type Value = Option<T>;
method try_write (line 922) | fn try_write(&self) -> Option<impl UntrackableGuard<Target = Self::Value...
method try_write_untracked (line 926) | fn try_write_untracked(
type Value (line 937) | type Value = <AsyncDerived<T> as ReadUntracked>::Value;
method try_read_untracked (line 940) | fn try_read_untracked(&self) -> Option<Self::Value> {
function new_str (line 989) | pub fn new_str<S, Fut>(
function new_str_blocking (line 1015) | pub fn new_str_blocking<S, Fut>(
function new (line 1049) | pub fn new<S, Fut>(
function new_blocking (line 1075) | pub fn new_blocking<S, Fut>(
function new_serde_wb (line 1108) | pub fn new_serde_wb<S, Fut>(
function new_serde_wb_blocking (line 1133) | pub fn new_serde_wb_blocking<S, Fut>(
function new_miniserde (line 1168) | pub fn new_miniserde<S, Fut>(
function new_miniserde_blocking (line 1193) | pub fn new_miniserde_blocking<S, Fut>(
function new_serde_lite (line 1227) | pub fn new_serde_lite<S, Fut>(
function new_serde_lite_blocking (line 1252) | pub fn new_serde_lite_blocking<S, Fut>(
function new_rkyv (line 1287) | pub fn new_rkyv<S, Fut>(
function new_rkyv_blocking (line 1312) | pub fn new_rkyv_blocking<S, Fut>(
function new_with_options (line 1351) | pub fn new_with_options<S, Fut>(
function map (line 1374) | pub fn map<U>(&self, f: impl FnOnce(&T) -> U) -> Option<U> {
function refetch (line 1381) | pub fn refetch(&self) {
function and_then (line 1406) | pub fn and_then<U>(&self, f: impl FnOnce(&T) -> U) -> Option<Result<U, E...
type Output (line 1415) | type Output = T;
type IntoFuture (line 1416) | type IntoFuture = AsyncDerivedFuture<T>;
method into_future (line 1419) | fn into_future(self) -> Self::IntoFuture {
function by_ref (line 1430) | pub fn by_ref(&self) -> AsyncDerivedRefFuture<T> {
FILE: leptos_server/src/serializers.rs
type SerializableData (line 4) | pub trait SerializableData<Ser: Serializer>: Sized {
method ser (line 8) | fn ser(&self) -> Result<String, Self::SerErr>;
method de (line 10) | fn de(data: &str) -> Result<Self, Self::DeErr>;
type Serializer (line 13) | pub trait Serializer {}
type Str (line 17) | pub struct Str;
type SerErr (line 25) | type SerErr = ();
type DeErr (line 26) | type DeErr = <T as FromStr>::Err;
method ser (line 28) | fn ser(&self) -> Result<String, Self::SerErr> {
method de (line 32) | fn de(data: &str) -> Result<Self, Self::DeErr> {
type SerdeJson (line 38) | pub struct SerdeJson;
type SerErr (line 46) | type SerErr = serde_json::Error;
type DeErr (line 47) | type DeErr = serde_json::Error;
method ser (line 49) | fn ser(&self) -> Result<String, Self::SerErr> {
method de (line 53) | fn de(data: &str) -> Result<Self, Self::DeErr> {
type Miniserde (line 64) | pub struct Miniserde;
type SerErr (line 72) | type SerErr = ();
type DeErr (line 73) | type DeErr = miniserde::Error;
method ser (line 75) | fn ser(&self) -> Result<String, Self::SerErr> {
method de (line 79) | fn de(data: &str) -> Result<Self, Self::DeErr> {
type SerdeLiteError (line 94) | pub enum SerdeLiteError {
method from (line 102) | fn from(value: serde_lite::Error) -> Self {
method from (line 108) | fn from(value: serde_json::Error) -> Self {
type SerdeLite (line 114) | pub struct SerdeLite;
type SerErr (line 122) | type SerErr = SerdeLiteError;
type DeErr (line 123) | type DeErr = SerdeLiteError;
method ser (line 125) | fn ser(&self) -> Result<String, Self::SerErr> {
method de (line 130) | fn de(data: &str) -> Result<Self, Self::DeErr> {
type Rkyv (line 153) | pub struct Rkyv;
type RkyvError (line 158) | pub enum RkyvError {
method from (line 166) | fn from(value: Arc<dyn Error>) -> Self {
method from (line 172) | fn from(value: base64::DecodeError) -> Self {
type SerErr (line 184) | type SerErr = RkyvError;
type DeErr (line 185) | type DeErr = RkyvError;
method ser (line 187) | fn ser(&self) -> Result<String, Self::SerErr> {
method de (line 193) | fn de(data: &str) -> Result<Self, Self::DeErr> {
type SerdeWasmBindgen (line 211) | pub struct SerdeWasmBindgen;
type SerErr (line 219) | type SerErr = serde_json::Error;
type DeErr (line 220) | type DeErr = wasm_bindgen::JsValue;
method ser (line 222) | fn ser(&self) -> Result<String, Self::SerErr> {
method de (line 226) | fn de(data: &str) -> Result<Self, Self::DeErr> {
FILE: leptos_server/src/shared.rs
type SharedValue (line 28) | pub struct SharedValue<T, Ser = JsonSerdeCodec> {
function into_inner (line 35) | pub fn into_inner(self) -> T {
function new (line 56) | pub fn new(initial: impl FnOnce() -> T) -> Self {
function new_str (line 77) | pub fn new_str(initial: impl FnOnce() -> T) -> Self {
function new_serde_lite (line 100) | pub fn new_serde_lite(initial: impl FnOnce() -> T) -> Self {
function new_serde_wb (line 123) | pub fn new_serde_wb(initial: impl FnOnce() -> T) -> Self {
function new_miniserde (line 146) | pub fn new_miniserde(initial: impl FnOnce() -> T) -> Self {
function new_rkyv (line 169) | pub fn new_rkyv(initial: impl FnOnce() -> T) -> Self {
function new_with_encoding (line 190) | pub fn new_with_encoding(initial: impl FnOnce() -> T) -> Self {
type Target (line 267) | type Target = T;
method deref (line 269) | fn deref(&self) -> &Self::Target {
method deref_mut (line 275) | fn deref_mut(&mut self) -> &mut Self::Target {
method eq (line 284) | fn eq(&self, other: &Self) -> bool {
method fmt (line 295) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
method hash (line 304) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
method partial_cmp (line 313) | fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
method cmp (line 322) | fn cmp(&self, other: &Self) -> std::cmp::Ordering {
FILE: meta/src/body.rs
function Body (line 48) | pub fn Body() -> impl IntoView {
type BodyView (line 52) | struct BodyView<At> {
type BodyViewState (line 56) | struct BodyViewState<At>
type State (line 67) | type State = BodyViewState<At>;
method build (line 69) | fn build(self) -> Self::State {
method rebuild (line 76) | fn rebuild(self, state: &mut Self::State) {
type Output (line 85) | type Output<SomeNewAttr: Attribute> =
method add_any_attr (line 88) | fn add_any_attr<NewAttr: Attribute>(
type AsyncOutput (line 105) | type AsyncOutput = BodyView<At::AsyncOutput>;
type Owned (line 106) | type Owned = BodyView<At::CloneableOwned>;
constant MIN_LENGTH (line 108) | const MIN_LENGTH: usize = At::MIN_LENGTH;
method dry_resolve (line 110) | fn dry_resolve(&mut self) {
method resolve (line 114) | async fn resolve(self) -> Self::AsyncOutput {
method to_html_with_buf (line 120) | fn to_html_with_buf(
method hydrate (line 140) | fn hydrate<const FROM_SERVER: bool>(
method into_owned (line 151) | fn into_owned(self) -> Self::Owned {
method unmount (line 162) | fn unmount(&mut self) {}
method mount (line 164) | fn mount(
method insert_before_this (line 171) | fn insert_before_this(&self, _child: &mut dyn Mountable) -> bool {
method elements (line 175) | fn elements(&self) -> Vec<leptos::tachys::renderer::types::Element> {
FILE: meta/src/html.rs
function Html (line 45) | pub fn Html() -> impl IntoView {
type HtmlView (line 49) | struct HtmlView<At> {
type HtmlViewState (line 53) | struct HtmlViewState<At>
type State (line 64) | type State = HtmlViewState<At>;
method build (line 66) | fn build(self) -> Self::State {
method rebuild (line 76) | fn rebuild(self, state: &mut Self::State) {
type Output (line 85) | type Output<SomeNewAttr: Attribute> =
method add_any_attr (line 88) | fn add_any_attr<NewAttr: Attribute>(
type AsyncOutput (line 105) | type AsyncOutput = HtmlView<At::AsyncOutput>;
type Owned (line 106) | type Owned = HtmlView<At::CloneableOwned>;
constant MIN_LENGTH (line 108) | const MIN_LENGTH: usize = At::MIN_LENGTH;
method dry_resolve (line 110) | fn dry_resolve(&mut self) {
method resolve (line 114) | async fn resolve(self) -> Self::AsyncOutput {
method to_html_with_buf (line 120) | fn to_html_with_buf(
method hydrate (line 140) | fn hydrate<const FROM_SERVER: bool>(
method into_owned (line 154) | fn into_owned(self) -> Self::Owned {
method unmount (line 165) | fn unmount(&mut self) {}
method mount (line 167) | fn mount(
method insert_before_this (line 176) | fn insert_before_this(&self, _child: &mut dyn Mountable) -> bool {
method elements (line 180) | fn elements(&self) -> Vec<leptos::tachys::renderer::types::Element> {
FILE: meta/src/lib.rs
type MetaContext (line 99) | pub struct MetaContext {
method new (line 108) | pub fn new() -> Self {
constant HEAD_MARKER_COMMENT (line 113) | pub(crate) const HEAD_MARKER_COMMENT: &str = "HEAD";
constant COMMENT_NODE (line 116) | const COMMENT_NODE: u16 = 8;
method default (line 119) | fn default() -> Self {
type ServerMetaContext (line 162) | pub struct ServerMetaContext {
method new (line 187) | pub fn new() -> (ServerMetaContext, ServerMetaContextOutput) {
type ServerMetaContextOutput (line 178) | pub struct ServerMetaContextOutput {
method inject_meta_context (line 214) | pub async fn inject_meta_context(
function provide_meta_context (line 293) | pub fn provide_meta_context() {
function use_head (line 307) | pub fn use_head() -> MetaContext {
function register (line 325) | pub(crate) fn register<E, At, Ch>(
type RegisteredMetaTag (line 334) | struct RegisteredMetaTag<E, At, Ch> {
type RegisteredMetaTagState (line 340) | struct RegisteredMetaTagState<E, At, Ch>
method drop (line 351) | fn drop(&mut self) {
function document_head (line 356) | fn document_head() -> HtmlHeadElement {
type State (line 372) | type State = RegisteredMetaTagState<E, At, Ch>;
method build (line 374) | fn build(self) -> Self::State {
method rebuild (line 379) | fn rebuild(self, state: &mut Self::State) {
type Output (line 390) | type Output<SomeNewAttr: Attribute> =
method add_any_attr (line 393) | fn add_any_attr<NewAttr: Attribute>(
type AsyncOutput (line 412) | type AsyncOutput = Self;
type Owned (line 413) | type Owned = RegisteredMetaTag<E, At::CloneableOwned, Ch::Owned>;
constant MIN_LENGTH (line 415) | const MIN_LENGTH: usize = 0;
constant EXISTS (line 416) | const EXISTS: bool = false;
method dry_resolve (line 418) | fn dry_resolve(&mut self) {
method resolve (line 422) | async fn resolve(self) -> Self::AsyncOutput {
method to_html_with_buf (line 426) | fn to_html_with_buf(
method hydrate (line 459) | fn hydrate<const FROM_SERVER: bool>(
method into_owned (line 477) | fn into_owned(self) -> Self::Owned {
method unmount (line 490) | fn unmount(&mut self) {
method mount (line 494) | fn mount(
method insert_before_this (line 506) | fn insert_before_this(&self, _child: &mut dyn Mountable) -> bool {
method elements (line 515) | fn elements(&self) -> Vec<leptos::tachys::renderer::types::Element> {
function MetaTags (line 524) | pub fn MetaTags() -> impl IntoView {
type MetaTagsView (line 529) | struct MetaTagsView;
type State (line 536) | type State = ();
method build (line 538) | fn build(self) -> Self::State {}
method rebuild (line 540) | fn rebuild(self, _state: &mut Self::State) {}
type Output (line 544) | type Output<SomeNewAttr: Attribute> = MetaTagsView;
method add_any_attr (line 546) | fn add_any_attr<NewAttr: Attribute>(
type AsyncOutput (line 558) | type AsyncOutput = Self;
type Owned (line 559) | type Owned = Self;
constant MIN_LENGTH (line 561) | const MIN_LENGTH: usize = 0;
method dry_resolve (line 563) | fn dry_resolve(&mut self) {}
method resolve (line 565) | async fn resolve(self) -> Self::AsyncOutput {
method to_html_with_buf (line 569) | fn to_html_with_buf(
method hydrate (line 580) | fn hydrate<const FROM_SERVER: bool>(
method into_owned (line 587) | fn into_owned(self) -> Self::Owned {
type OrDefaultNonce (line 592) | pub(crate) trait OrDefaultNonce {
method or_default_nonce (line 593) | fn or_default_nonce(self) -> Option<Oco<'static, str>>;
method or_default_nonce (line 597) | fn or_default_nonce(self) -> Option<Oco<'static, str>> {
FILE: meta/src/link.rs
function Link (line 31) | pub fn Link(
FILE: meta/src/meta_tags.rs
function Meta (line 31) | pub fn Meta(
FILE: meta/src/script.rs
function Script (line 27) | pub fn Script(
FILE: meta/src/style.rs
function Style (line 27)
Condensed preview — 1358 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (5,146K chars).
[
{
"path": ".config/nextest.toml",
"chars": 2081,
"preview": "experimental = [\"setup-scripts\"]\n\n# For tests that need to run one at a time to avoid resource contention from\n# paralle"
},
{
"path": ".github/FUNDING.yml",
"chars": 59,
"preview": "# These are supported funding model platforms\n\ngithub: gbj\n"
},
{
"path": ".github/ISSUE_TEMPLATE/bug_report.md",
"chars": 987,
"preview": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n**Describe the b"
},
{
"path": ".github/ISSUE_TEMPLATE/config.yml",
"chars": 430,
"preview": "contact_links:\n - name: Support or Question\n url: https://github.com/leptos-rs/leptos/discussions/new?category=q-a\n "
},
{
"path": ".github/ISSUE_TEMPLATE/feature_request.md",
"chars": 595,
"preview": "---\nname: Feature request\nabout: Suggest an idea for this project\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n**Is your fea"
},
{
"path": ".github/dependabot.yml",
"chars": 413,
"preview": "version: 2\nupdates:\n - package-ecosystem: \"github-actions\"\n directory: \"/\"\n schedule:\n interval: \"weekly\"\n "
},
{
"path": ".github/workflows/autofix.yml",
"chars": 1298,
"preview": "name: autofix.ci\non:\n pull_request:\n # Running this workflow on main branch pushes requires write permission to apply "
},
{
"path": ".github/workflows/ci.yml",
"chars": 2262,
"preview": "name: CI\non:\n push:\n branches:\n - main\n - leptos_0.6\n - leptos_0.8\n pull_request:\n branches:\n "
},
{
"path": ".github/workflows/get-example-changed.yml",
"chars": 1696,
"preview": "name: Examples Changed Call\non:\n workflow_call:\n outputs:\n example_changed:\n description: \"Example Chang"
},
{
"path": ".github/workflows/get-examples-matrix.yml",
"chars": 1068,
"preview": "name: Get Examples Matrix Call\non:\n workflow_call:\n outputs:\n matrix:\n description: \"Matrix\"\n val"
},
{
"path": ".github/workflows/get-leptos-changed.yml",
"chars": 1054,
"preview": "name: Get Leptos Changed Call\non:\n workflow_call:\n outputs:\n leptos_changed:\n description: \"Leptos Chang"
},
{
"path": ".github/workflows/get-leptos-matrix.yml",
"chars": 990,
"preview": "name: Get Leptos Matrix Call\non:\n workflow_call:\n outputs:\n matrix:\n description: \"Matrix\"\n value"
},
{
"path": ".github/workflows/publish-book.yml",
"chars": 1129,
"preview": "name: Deploy book\non:\n push:\n paths: [\"docs/book/**\"]\n branches:\n - main\n\njobs:\n deploy:\n runs-on: ubunt"
},
{
"path": ".github/workflows/run-cargo-make-task.yml",
"chars": 7405,
"preview": "name: Run Task\non:\n workflow_call:\n inputs:\n directory:\n required: true\n type: string\nenv:\n CARG"
},
{
"path": ".gitignore",
"chars": 183,
"preview": "target\ndist\npkg\ncomparisons\nblob.rs\n**/projects/**/Cargo.lock\n**/examples/**/Cargo.lock\n**/benchmarks/**/Cargo.lock\n**/*"
},
{
"path": "ARCHITECTURE.md",
"chars": 9781,
"preview": "# Architecture\n\nThe goal of this document is to make it easier for contributors (and anyone\nwho’s interested!) to unders"
},
{
"path": "CODE_OF_CONDUCT.md",
"chars": 4537,
"preview": "# Contributor Covenant Code of Conduct\n\n_This Code of Conduct is based on the [Rust Code of Conduct](https://www.rust-la"
},
{
"path": "CONTRIBUTING.md",
"chars": 5158,
"preview": "# Contributing to Leptos\n\nThanks for your interesting in contributing to Leptos! This is a truly\ncommunity-driven framew"
},
{
"path": "Cargo.toml",
"chars": 8607,
"preview": "[workspace]\nresolver = \"2\"\nmembers = [\n # utilities\n \"any_spawner\",\n \"const_str_slice_concat\",\n \"either_of\",\n \"next"
},
{
"path": "LICENSE",
"chars": 1070,
"preview": "MIT License\n\nCopyright (c) 2022 Greg Johnston\n\nPermission is hereby granted, free of charge, to any person obtaining a c"
},
{
"path": "Makefile.toml",
"chars": 781,
"preview": "############\n# A make file for cargo-make, please install it with:\n# cargo install --force cargo-make\n############\n\n"
},
{
"path": "README.md",
"chars": 13202,
"preview": "<picture>\n <source srcset=\"https://raw.githubusercontent.com/leptos-rs/leptos/main/docs/logos/Leptos_logo_pref_dark_R"
},
{
"path": "SECURITY.md",
"chars": 539,
"preview": "# Security Policy\n\n## Reporting a Vulnerability\n\nTo report a suspected security issue, please contact security@leptos.de"
},
{
"path": "TODO.md",
"chars": 1059,
"preview": "- core examples\n - [x] counter\n - [x] counters\n - [x] fetch\n - [x] todomvc \n - [x] error_boundary\n - ["
},
{
"path": "any_error/Cargo.toml",
"chars": 419,
"preview": "[package]\nname = \"throw_error\"\nversion = \"0.3.1\"\nauthors = [\"Greg Johnston\"]\nlicense = \"MIT\"\nreadme = \"../README.md\"\nrep"
},
{
"path": "any_error/Makefile.toml",
"chars": 46,
"preview": "extend = { path = \"../cargo-make/main.toml\" }\n"
},
{
"path": "any_error/README.md",
"chars": 132,
"preview": "A utility library for wrapping arbitrary errors, and for “throwing” errors in a way\nthat can be caught by user-defined e"
},
{
"path": "any_error/src/lib.rs",
"chars": 5080,
"preview": "#![forbid(unsafe_code)]\n#![deny(missing_docs)]\n\n//! A utility library for wrapping arbitrary errors, and for “throwing” "
},
{
"path": "any_spawner/Cargo.toml",
"chars": 1516,
"preview": "[package]\nname = \"any_spawner\"\nversion = \"0.3.0\"\nauthors = [\"Greg Johnston\"]\nlicense = \"MIT\"\nreadme = \"../README.md\"\nrep"
},
{
"path": "any_spawner/Makefile.toml",
"chars": 98,
"preview": "extend = [\n { path = \"../cargo-make/main.toml\" },\n { path = \"../cargo-make/wasm-test.toml\" },\n]\n"
},
{
"path": "any_spawner/README.md",
"chars": 917,
"preview": "This crate makes it easier to write asynchronous code that is executor-agnostic, by providing a\nutility that can be used"
},
{
"path": "any_spawner/src/lib.rs",
"chars": 18983,
"preview": "//! This crate makes it easier to write asynchronous code that is executor-agnostic, by providing a\n//! utility that can"
},
{
"path": "any_spawner/tests/already_set_error.rs",
"chars": 864,
"preview": "use any_spawner::{Executor, ExecutorError};\n\n#[test]\nfn test_already_set_error() {\n struct SimpleExecutor;\n\n impl "
},
{
"path": "any_spawner/tests/async_executor.rs",
"chars": 1950,
"preview": "#![cfg(feature = \"async-executor\")]\n\nuse std::{\n future::Future,\n pin::Pin,\n sync::{Arc, Mutex},\n};\n\n// A simpl"
},
{
"path": "any_spawner/tests/custom_executor.rs",
"chars": 1918,
"preview": "use any_spawner::Executor;\nuse std::sync::{\n atomic::{AtomicBool, Ordering},\n Arc,\n};\n\n#[test]\nfn test_custom_exec"
},
{
"path": "any_spawner/tests/custom_runtime.rs",
"chars": 1697,
"preview": "#![cfg(feature = \"futures-executor\")]\n\nuse any_spawner::{CustomExecutor, Executor, PinnedFuture, PinnedLocalFuture};\n\n#["
},
{
"path": "any_spawner/tests/executor_tick.rs",
"chars": 709,
"preview": "#![cfg(feature = \"tokio\")]\n\nuse any_spawner::Executor;\nuse std::{\n sync::{Arc, Mutex},\n time::Duration,\n};\n\n#[toki"
},
{
"path": "any_spawner/tests/futures_executor.rs",
"chars": 1110,
"preview": "#![cfg(feature = \"futures-executor\")]\n\nuse any_spawner::Executor;\nuse futures::channel::oneshot;\nuse std::{\n sync::{A"
},
{
"path": "any_spawner/tests/futures_runtime.rs",
"chars": 912,
"preview": "#![cfg(feature = \"futures-executor\")]\n\nuse any_spawner::Executor;\n// All tests in this file use the same executor.\n\n#[te"
},
{
"path": "any_spawner/tests/glib.rs",
"chars": 4143,
"preview": "#![cfg(feature = \"glib\")]\n\nuse any_spawner::Executor;\nuse glib::{MainContext, MainLoop};\nuse serial_test::serial;\nuse st"
},
{
"path": "any_spawner/tests/local_custom_executor.rs",
"chars": 1655,
"preview": "use any_spawner::Executor;\nuse std::sync::{\n atomic::{AtomicBool, Ordering},\n Arc,\n};\n\n#[test]\nfn test_local_custo"
},
{
"path": "any_spawner/tests/multiple_tasks.rs",
"chars": 926,
"preview": "#![cfg(feature = \"tokio\")]\n\nuse any_spawner::Executor;\nuse futures::channel::oneshot;\nuse std::sync::{Arc, Mutex};\n\n#[to"
},
{
"path": "any_spawner/tests/tokio_executor.rs",
"chars": 506,
"preview": "#![cfg(feature = \"tokio\")]\n\nuse any_spawner::Executor;\nuse futures::channel::oneshot;\n\n#[tokio::test]\nasync fn test_toki"
},
{
"path": "any_spawner/tests/wasm_bindgen_tests.rs",
"chars": 2538,
"preview": "#![cfg(all(feature = \"wasm-bindgen\", target_family = \"wasm\"))]\n\nuse any_spawner::Executor;\nuse futures::channel::oneshot"
},
{
"path": "benchmarks/Cargo.toml",
"chars": 1017,
"preview": "[package]\nname = \"benchmarks\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[dependencies]\nl0410 = { package = \"leptos\", version ="
},
{
"path": "benchmarks/src/lib.rs",
"chars": 75,
"preview": "#![feature(test)]\n\nextern crate test;\n\nmod reactive;\nmod ssr;\nmod todomvc;\n"
},
{
"path": "benchmarks/src/reactive.rs",
"chars": 12229,
"preview": "use std::{cell::Cell, rc::Rc};\nuse test::Bencher;\n\n#[bench]\nfn leptos_deep_creation(b: &mut Bencher) {\n use leptos::*"
},
{
"path": "benchmarks/src/ssr.rs",
"chars": 7385,
"preview": "use test::Bencher;\n\n#[bench]\nfn leptos_ssr_bench(b: &mut Bencher) {\n\tuse leptos::*;\n\tlet r = create_runtime();\n b.ite"
},
{
"path": "benchmarks/src/todomvc/leptos.rs",
"chars": 10608,
"preview": "pub use leptos::*;\nuse miniserde::*;\nuse wasm_bindgen::JsCast;\nuse web_sys::HtmlInputElement;\n\n#[derive(Debug, Clone, Pa"
},
{
"path": "benchmarks/src/todomvc/mod.rs",
"chars": 4252,
"preview": "use test::Bencher;\n\nmod leptos;\nmod sycamore;\nmod tachys;\nmod tera;\nmod yew;\n\n#[bench]\nfn leptos_todomvc_ssr(b: &mut Ben"
},
{
"path": "benchmarks/src/todomvc/sycamore.rs",
"chars": 12001,
"preview": "use serde::{Deserialize, Serialize};\nuse sycamore::prelude::*;\nuse uuid::Uuid;\nuse wasm_bindgen::JsCast;\nuse web_sys::{E"
},
{
"path": "benchmarks/src/todomvc/tachys.rs",
"chars": 10002,
"preview": "pub use leptos_reactive::*;\nuse miniserde::*;\nuse tachy_maccy::view;\nuse tachydom::{\n html::{\n attribute::glob"
},
{
"path": "benchmarks/src/todomvc/tera.rs",
"chars": 5420,
"preview": "use test::Bencher;\n\nstatic TEMPLATE: &str = r#\"<main>\n <section class=\"todoapp\">\n <header clas"
},
{
"path": "benchmarks/src/todomvc/yew.rs",
"chars": 20041,
"preview": "use gloo::storage::{LocalStorage, Storage};\nuse strum::IntoEnumIterator;\nuse web_sys::HtmlInputElement as InputElement;\n"
},
{
"path": "cargo-make/check-minimal-versions.toml",
"chars": 268,
"preview": "[tasks.check-minimal-versions]\ncondition = { channels = [\"nightly\"] }\ncommand = \"cargo\"\nargs = [\n \"all-features\",\n \"mi"
},
{
"path": "cargo-make/lint.toml",
"chars": 421,
"preview": "[tasks.lint]\ndependencies = [\"check-format-flow\", \"clippy-each-feature\"]\n\n[tasks.check-format]\nenv = { LEPTOS_PROJECT_DI"
},
{
"path": "cargo-make/main.toml",
"chars": 334,
"preview": "extend = [\n { path = \"./lint.toml\" },\n { path = \"./test.toml\" },\n { path = \"./check-minimal-versions.toml\" },\n]\n\n[env"
},
{
"path": "cargo-make/test.toml",
"chars": 444,
"preview": "[tasks.test-each-feature]\nenv = { \"NEXTEST_NO_TESTS\" = \"warn\" }\ncommand = \"cargo\"\nargs = [\"all-features\", \"nextest\", \"ru"
},
{
"path": "cargo-make/wasm-test.toml",
"chars": 202,
"preview": "[tasks.post-test]\ndependencies = [\"test-wasm\"]\n\n[tasks.test-wasm]\nenv = { CARGO_MAKE_WASM_TEST_ARGS = \"--headless --chro"
},
{
"path": "const_str_slice_concat/Cargo.toml",
"chars": 318,
"preview": "[package]\nname = \"const_str_slice_concat\"\nversion = \"0.1.0\"\nauthors = [\"Greg Johnston\"]\nlicense = \"MIT\"\nreadme = \"../REA"
},
{
"path": "const_str_slice_concat/Makefile.toml",
"chars": 46,
"preview": "extend = { path = \"../cargo-make/main.toml\" }\n"
},
{
"path": "const_str_slice_concat/src/lib.rs",
"chars": 3723,
"preview": "#![no_std]\n#![forbid(unsafe_code)]\n#![deny(missing_docs)]\n\n//! Utilities for const concatenation of string slices.\n\npub("
},
{
"path": "docs/COMMON_BUGS.md",
"chars": 2799,
"preview": "# Leptos Gotchas: Common Bugs\n\nThis document is intended as a running list of common issues, with example code and solut"
},
{
"path": "docs/book_ru/.gitignore",
"chars": 4,
"preview": "book"
},
{
"path": "docs/book_ru/README.md",
"chars": 98,
"preview": "Перевод в процессе, книга скоро будет доступна\n> Translation underway, book will be available soon"
},
{
"path": "docs/book_ru/book.toml",
"chars": 251,
"preview": "[output.html]\nadditional-css = [\"./mdbook-admonish.css\"]\n[output.html.playground]\nrunnable = false\n\n[preprocessor]\n\n[pre"
},
{
"path": "docs/book_ru/mdbook-admonish.css",
"chars": 14818,
"preview": "@charset \"UTF-8\";\n:root {\n --md-admonition-icon--admonish-note: url(\"data:image/svg+xml;charset=utf-8,<svg xmlns='http:"
},
{
"path": "docs/book_ru/src/01_introduction.md",
"chars": 125,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/\">\n<link rel=\"canonical\" href=\"https://book.leptos.de"
},
{
"path": "docs/book_ru/src/15_global_state.md",
"chars": 165,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/15_global_state.html\">\n<link rel=\"canonical\" href=\"ht"
},
{
"path": "docs/book_ru/src/SUMMARY.md",
"chars": 2968,
"preview": "# Оглавление\n\n- [Вступление](./01_introduction.md)\n- [Начало работы](./getting_started/README.md)\n - [Leptos DX](./gett"
},
{
"path": "docs/book_ru/src/appendix_reactive_graph.md",
"chars": 181,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/appendix_reactive_graph.html\">\n<link rel=\"canonical\" "
},
{
"path": "docs/book_ru/src/async/10_resources.md",
"chars": 171,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/async/10_resources.html\">\n<link rel=\"canonical\" href="
},
{
"path": "docs/book_ru/src/async/11_suspense.md",
"chars": 169,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/async/11_suspense.html\">\n<link rel=\"canonical\" href=\""
},
{
"path": "docs/book_ru/src/async/12_transition.md",
"chars": 173,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/async/12_transition.html\">\n<link rel=\"canonical\" href"
},
{
"path": "docs/book_ru/src/async/13_actions.md",
"chars": 165,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/async/13_action.html\">\n<link rel=\"canonical\" href=\"ht"
},
{
"path": "docs/book_ru/src/async/README.md",
"chars": 157,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/async/index.html\">\n<link rel=\"canonical\" href=\"https:"
},
{
"path": "docs/book_ru/src/csr_wrapping_up.md",
"chars": 165,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/csr_wrapping_up.html\">\n<link rel=\"canonical\" href=\"ht"
},
{
"path": "docs/book_ru/src/deployment/README.md",
"chars": 167,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/deployment/index.html\">\n<link rel=\"canonical\" href=\"h"
},
{
"path": "docs/book_ru/src/deployment/binary_size.md",
"chars": 179,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/deployment/binary_size.html\">\n<link rel=\"canonical\" h"
},
{
"path": "docs/book_ru/src/getting_started/README.md",
"chars": 177,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/getting_started/index.html\">\n<link rel=\"canonical\" hr"
},
{
"path": "docs/book_ru/src/getting_started/community_crates.md",
"chars": 199,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/getting_started/community_crates.html\">\n<link rel=\"ca"
},
{
"path": "docs/book_ru/src/getting_started/leptos_dx.md",
"chars": 185,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/getting_started/leptos_dx.html\">\n<link rel=\"canonical"
},
{
"path": "docs/book_ru/src/interlude_projecting_children.md",
"chars": 193,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/interlude_projecting_children.html\">\n<link rel=\"canon"
},
{
"path": "docs/book_ru/src/interlude_styling.md",
"chars": 169,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/interlude_styling.html\">\n<link rel=\"canonical\" href=\""
},
{
"path": "docs/book_ru/src/islands.md",
"chars": 149,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/islands.html\">\n<link rel=\"canonical\" href=\"https://bo"
},
{
"path": "docs/book_ru/src/metadata.md",
"chars": 151,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/metadata.html\">\n<link rel=\"canonical\" href=\"https://b"
},
{
"path": "docs/book_ru/src/progressive_enhancement/README.md",
"chars": 193,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/progressive_enhancement/index.html\">\n<link rel=\"canon"
},
{
"path": "docs/book_ru/src/progressive_enhancement/action_form.md",
"chars": 205,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/progressive_enhancement/action_form.html\">\n<link rel="
},
{
"path": "docs/book_ru/src/reactivity/14_create_effect.md",
"chars": 189,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/reactivity/14_create_effect.html\">\n<link rel=\"canonic"
},
{
"path": "docs/book_ru/src/reactivity/README.md",
"chars": 167,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/reactivity/index.html\">\n<link rel=\"canonical\" href=\"h"
},
{
"path": "docs/book_ru/src/reactivity/interlude_functions.md",
"chars": 195,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/reactivity/interlude_functions.html\">\n<link rel=\"cano"
},
{
"path": "docs/book_ru/src/reactivity/working_with_signals.md",
"chars": 197,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/reactivity/working_with_signals.html\">\n<link rel=\"can"
},
{
"path": "docs/book_ru/src/router/16_routes.md",
"chars": 167,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/router/16_routes.html\">\n<link rel=\"canonical\" href=\"h"
},
{
"path": "docs/book_ru/src/router/17_nested_routing.md",
"chars": 183,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/router/17_nested_routing.html\">\n<link rel=\"canonical\""
},
{
"path": "docs/book_ru/src/router/18_params_and_queries.md",
"chars": 191,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/router/18_params_and_queries.html\">\n<link rel=\"canoni"
},
{
"path": "docs/book_ru/src/router/19_a.md",
"chars": 157,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/router/19_a.html\">\n<link rel=\"canonical\" href=\"https:"
},
{
"path": "docs/book_ru/src/router/20_form.md",
"chars": 163,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/router/20_form.html\">\n<link rel=\"canonical\" href=\"htt"
},
{
"path": "docs/book_ru/src/router/README.md",
"chars": 159,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/router/index.html\">\n<link rel=\"canonical\" href=\"https"
},
{
"path": "docs/book_ru/src/server/25_server_functions.md",
"chars": 187,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/server/25_server_functions.html\">\n<link rel=\"canonica"
},
{
"path": "docs/book_ru/src/server/26_extractors.md",
"chars": 175,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/server/26_extractors.html\">\n<link rel=\"canonical\" hre"
},
{
"path": "docs/book_ru/src/server/27_response.md",
"chars": 171,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/server/27_response.html\">\n<link rel=\"canonical\" href="
},
{
"path": "docs/book_ru/src/server/README.md",
"chars": 159,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/server/index.html\">\n<link rel=\"canonical\" href=\"https"
},
{
"path": "docs/book_ru/src/ssr/21_cargo_leptos.md",
"chars": 173,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/ssr/21_cargo_leptos.html\">\n<link rel=\"canonical\" href"
},
{
"path": "docs/book_ru/src/ssr/22_life_cycle.md",
"chars": 169,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/ssr/22_life_cycle.html\">\n<link rel=\"canonical\" href=\""
},
{
"path": "docs/book_ru/src/ssr/23_ssr_modes.md",
"chars": 167,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/ssr/23_ssr_modes.html\">\n<link rel=\"canonical\" href=\"h"
},
{
"path": "docs/book_ru/src/ssr/24_hydration_bugs.md",
"chars": 177,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/ssr/24_hydration_bugs.html\">\n<link rel=\"canonical\" hr"
},
{
"path": "docs/book_ru/src/ssr/README.md",
"chars": 153,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/ssr/index.html\">\n<link rel=\"canonical\" href=\"https://"
},
{
"path": "docs/book_ru/src/testing.md",
"chars": 149,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/testing.html\">\n<link rel=\"canonical\" href=\"https://bo"
},
{
"path": "docs/book_ru/src/view/01_basic_component.md",
"chars": 181,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/view/01_basic_component.html\">\n<link rel=\"canonical\" "
},
{
"path": "docs/book_ru/src/view/02_dynamic_attributes.md",
"chars": 187,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/view/02_dynamic_attributes.html\">\n<link rel=\"canonica"
},
{
"path": "docs/book_ru/src/view/03_components.md",
"chars": 171,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/view/03_components.html\">\n<link rel=\"canonical\" href="
},
{
"path": "docs/book_ru/src/view/04_iteration.md",
"chars": 169,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/view/04_iteration.html\">\n<link rel=\"canonical\" href=\""
},
{
"path": "docs/book_ru/src/view/04b_iteration.md",
"chars": 171,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/view/04b_iteration.html\">\n<link rel=\"canonical\" href="
},
{
"path": "docs/book_ru/src/view/05_forms.md",
"chars": 161,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/view/05_forms.html\">\n<link rel=\"canonical\" href=\"http"
},
{
"path": "docs/book_ru/src/view/06_control_flow.md",
"chars": 175,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/view/06_control_flow.html\">\n<link rel=\"canonical\" hre"
},
{
"path": "docs/book_ru/src/view/07_errors.md",
"chars": 163,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/view/07_errors.html\">\n<link rel=\"canonical\" href=\"htt"
},
{
"path": "docs/book_ru/src/view/08_parent_child.md",
"chars": 175,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/view/08_parent_child.html\">\n<link rel=\"canonical\" hre"
},
{
"path": "docs/book_ru/src/view/09_component_children.md",
"chars": 187,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/view/09_component_children.html\">\n<link rel=\"canonica"
},
{
"path": "docs/book_ru/src/view/README.md",
"chars": 155,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/view/index.html\">\n<link rel=\"canonical\" href=\"https:/"
},
{
"path": "docs/book_ru/src/view/builder.md",
"chars": 159,
"preview": "<meta http-equiv=\"refresh\" content=\"0; URL=https://book.leptos.dev/view/builder.html\">\n<link rel=\"canonical\" href=\"https"
},
{
"path": "docs/logos/.gitignore",
"chars": 16,
"preview": "logo-working.svg"
},
{
"path": "either_of/Cargo.toml",
"chars": 499,
"preview": "[package]\nname = \"either_of\"\nversion = \"0.1.8\"\nauthors = [\"Greg Johnston\"]\nlicense = \"MIT\"\nreadme = \"../README.md\"\nrepos"
},
{
"path": "either_of/Makefile.toml",
"chars": 46,
"preview": "extend = { path = \"../cargo-make/main.toml\" }\n"
},
{
"path": "either_of/README.md",
"chars": 84,
"preview": "Utilities for working with enumerated types that contain one of `2..n` other types.\n"
},
{
"path": "either_of/src/lib.rs",
"chars": 50741,
"preview": "#![no_std]\n#![forbid(unsafe_code)]\n\n//! Utilities for working with enumerated types that contain one of `2..n` other typ"
},
{
"path": "examples/Makefile.toml",
"chars": 1383,
"preview": "extend = [{ path = \"./cargo-make/main.toml\" }]\n\n[env]\nCARGO_MAKE_EXTEND_WORKSPACE_MAKEFILE = true\nCARGO_MAKE_CARGO_BUILD"
},
{
"path": "examples/README.md",
"chars": 2663,
"preview": "# Examples README\n\n## Main Branch\n\nThe examples in this directory are all built and tested against the current `main` br"
},
{
"path": "examples/SSR_NOTES.md",
"chars": 2312,
"preview": "# Server Side Rendering\n\n## Cargo Leptos\n\ncargo-leptos is now the easiest and most featureful way to build server side r"
},
{
"path": "examples/action-form-error-handling/Cargo.toml",
"chars": 3143,
"preview": "[package]\nname = \"action-form-error-handling\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[lib]\ncrate-type = [\"cdylib\", \"rlib\"]\n"
},
{
"path": "examples/action-form-error-handling/Makefile.toml",
"chars": 164,
"preview": "extend = [\n { path = \"../cargo-make/main.toml\" },\n { path = \"../cargo-make/cargo-leptos.toml\" },\n]\n\n[env]\n\nCLIENT_"
},
{
"path": "examples/action-form-error-handling/README.md",
"chars": 197,
"preview": "# Action Form Error Handling Example\n\n## Getting Started\n\nSee the [Examples README](../README.md) for setup and run inst"
},
{
"path": "examples/action-form-error-handling/src/app.rs",
"chars": 2341,
"preview": "use leptos::{logging, prelude::*};\nuse leptos_router::{\n components::{FlatRoutes, Route, Router},\n StaticSegment,\n"
},
{
"path": "examples/action-form-error-handling/src/lib.rs",
"chars": 200,
"preview": "pub mod app;\n\n#[cfg(feature = \"hydrate\")]\n#[wasm_bindgen::prelude::wasm_bindgen]\npub fn hydrate() {\n use app::*;\n\n "
},
{
"path": "examples/action-form-error-handling/src/main.rs",
"chars": 2170,
"preview": "#[cfg(feature = \"ssr\")]\n#[actix_web::main]\nasync fn main() -> std::io::Result<()> {\n use action_form_error_handling::"
},
{
"path": "examples/action-form-error-handling/style/main.scss",
"chars": 175,
"preview": "body {\n\tfont-family: sans-serif;\n\ttext-align: center;\n}\n\n#app {\n\ttext-align: center;\n}\n\n.form {\n\tdisplay: flex;\n\tflex-di"
},
{
"path": "examples/axum_js_ssr/Cargo.toml",
"chars": 3993,
"preview": "[package]\nname = \"axum_js_ssr\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[lib]\ncrate-type = [\"cdylib\", \"rlib\"]\n\n[dependencies]"
},
{
"path": "examples/axum_js_ssr/LICENSE",
"chars": 1065,
"preview": "MIT License\n\nCopyright (c) 2024 Tommy Yu\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\no"
},
{
"path": "examples/axum_js_ssr/Makefile.toml",
"chars": 149,
"preview": "extend = [\n { path = \"../cargo-make/main.toml\" },\n { path = \"../cargo-make/cargo-leptos.toml\" },\n]\n\n[env]\n\nCLIENT_"
},
{
"path": "examples/axum_js_ssr/README.md",
"chars": 329,
"preview": "# Leptos Axum JS SSR Example\n\nThis example shows the various ways that JavaScript may be included into\na Leptos applicat"
},
{
"path": "examples/axum_js_ssr/package.json",
"chars": 95,
"preview": "{\n \"name\": \"axum_js_ssr\",\n \"dependencies\": {\n \"@highlightjs/cdn-assets\": \"^11.10.0\"\n }\n}\n"
},
{
"path": "examples/axum_js_ssr/src/api.rs",
"chars": 299,
"preview": "use leptos::{prelude::ServerFnError, server};\n\n#[server]\npub async fn fetch_code() -> Result<String, ServerFnError> {\n "
},
{
"path": "examples/axum_js_ssr/src/app.rs",
"chars": 58365,
"preview": "use crate::{\n api::fetch_code,\n consts::{CH03_05A, LEPTOS_HYDRATED},\n};\nuse leptos::prelude::*;\nuse leptos_meta::{"
},
{
"path": "examples/axum_js_ssr/src/consts.rs",
"chars": 910,
"preview": "// Example programs from the Rust Programming Language Book\n\npub const CH03_05A: &str = r#\"fn main() {\n let number = "
},
{
"path": "examples/axum_js_ssr/src/hljs.rs",
"chars": 2099,
"preview": "#[cfg(not(feature = \"ssr\"))]\nmod csr {\n use gloo_utils::format::JsValueSerdeExt;\n use js_sys::{\n Object,\n "
},
{
"path": "examples/axum_js_ssr/src/lib.rs",
"chars": 1732,
"preview": "pub mod api;\npub mod app;\npub mod consts;\npub mod hljs;\n\n#[cfg(feature = \"hydrate\")]\n#[wasm_bindgen::prelude::wasm_bindg"
},
{
"path": "examples/axum_js_ssr/src/main.rs",
"chars": 5319,
"preview": "#[cfg(feature = \"ssr\")]\nmod latency {\n use std::sync::{Mutex, OnceLock};\n pub static LATENCY: OnceLock<\n Mu"
},
{
"path": "examples/axum_js_ssr/style/main.scss",
"chars": 4821,
"preview": "html, body {\n margin: 0;\n padding: 0;\n font-family: sans-serif;\n height: 100vh;\n overflow: hidden;\n}\n\nbod"
},
{
"path": "examples/cargo-make/cargo-leptos-compress.toml",
"chars": 847,
"preview": "[tasks.make-target-site-dir]\ncommand = \"mkdir\"\nargs = [\"-p\", \"target/site\"]\n\n[tasks.install-cargo-leptos]\ninstall_crate "
},
{
"path": "examples/cargo-make/cargo-leptos-split-webdriver-test.toml",
"chars": 224,
"preview": "extend = [\n { path = \"./cargo-leptos.toml\" },\n { path = \"../cargo-make/webdriver.toml\" },\n]\n\n[tasks.integration-te"
},
{
"path": "examples/cargo-make/cargo-leptos-test.toml",
"chars": 128,
"preview": "extend = { path = \"./cargo-leptos.toml\" }\n\n[tasks.integration-test]\ndependencies = [\"install-cargo-leptos\", \"cargo-lepto"
},
{
"path": "examples/cargo-make/cargo-leptos-webdriver-test.toml",
"chars": 203,
"preview": "extend = [\n { path = \"./cargo-leptos.toml\" },\n { path = \"../cargo-make/webdriver.toml\" },\n]\n\n[tasks.integration-te"
},
{
"path": "examples/cargo-make/cargo-leptos.toml",
"chars": 891,
"preview": "[tasks.cargo-all-features]\ninstall_script = '''\ncargo install cargo-all-features\n'''\n\n[tasks.install-cargo-leptos]\ninsta"
},
{
"path": "examples/cargo-make/clean.toml",
"chars": 652,
"preview": "[tasks.clean]\ndependencies = [\n \"clean-cargo\",\n \"clean-trunk\",\n \"clean-node_modules\",\n \"clean-playwright\",\n \"clean-"
},
{
"path": "examples/cargo-make/client-process.toml",
"chars": 955,
"preview": "[tasks.start-client]\n\n[tasks.stop-client]\ncondition = { env_set = [\"CLIENT_PROCESS_NAME\"] }\nscript = '''\n if pidof -q $"
},
{
"path": "examples/cargo-make/compile.toml",
"chars": 189,
"preview": "[tasks.cargo-all-features]\ninstall_script = '''\ncargo install cargo-all-features\n'''\n\n[tasks.build]\ndependencies = [\"car"
},
{
"path": "examples/cargo-make/deno-build.toml",
"chars": 708,
"preview": "[tasks.cargo-all-features]\ninstall_script = '''\ncargo install cargo-all-features\n'''\n\n[tasks.build]\ninstall_crate = { cr"
},
{
"path": "examples/cargo-make/lint.toml",
"chars": 463,
"preview": "[tasks.cargo-all-features]\ninstall_script = '''\ncargo install cargo-all-features\n'''\n\n[tasks.lint]\ndependencies = [\"chec"
},
{
"path": "examples/cargo-make/main.toml",
"chars": 631,
"preview": "extend = [\n { path = \"./compile.toml\" },\n { path = \"./clean.toml\" },\n { path = \"./lint.toml\" },\n { path = \"./node.to"
},
{
"path": "examples/cargo-make/node.toml",
"chars": 990,
"preview": "[tasks.setup-node]\ndescription = \"Install node dependencies and playwright browsers\"\nenv = { PLAYWRIGHT_SKIP_BROWSER_DOW"
},
{
"path": "examples/cargo-make/playwright-test.toml",
"chars": 125,
"preview": "extend = [{ path = \"../cargo-make/playwright.toml\" }]\n\n[tasks.integration-test]\ndependencies = [\"test-playwright-autosta"
},
{
"path": "examples/cargo-make/playwright-trunk-test.toml",
"chars": 273,
"preview": "extend = [\n { path = \"../cargo-make/playwright.toml\" },\n { path = \"../cargo-make/trunk_server.toml\" },\n]\n\n[tasks.integ"
},
{
"path": "examples/cargo-make/playwright.toml",
"chars": 1900,
"preview": "[tasks.test-playwright-autostart]\ncommand = \"npm\"\nargs = [\"run\", \"e2e:auto-start\"]\n\n[tasks.test-playwright]\nscript = '''"
},
{
"path": "examples/cargo-make/process.toml",
"chars": 294,
"preview": "extend = [\n { path = \"./client-process.toml\" },\n { path = \"./server-process.toml\" },\n]\n\n[tasks.start]\ndependencies"
},
{
"path": "examples/cargo-make/scripts/web-report.sh",
"chars": 4799,
"preview": "#!/bin/bash\n\nset -emu\n\nBOLD=\"\\e[1m\"\nITALIC=\"\\e[3m\"\nYELLOW=\"\\e[1;33m\"\nBLUE=\"\\e[1;36m\"\nRESET=\"\\e[0m\"\n\nfunction web { #task"
},
{
"path": "examples/cargo-make/server-process.toml",
"chars": 930,
"preview": "[tasks.start-server]\n\n[tasks.stop-server]\ncondition = { env_set = [\"SERVER_PROCESS_NAME\"] }\nscript = '''\n if pidof -q $"
},
{
"path": "examples/cargo-make/trunk_server.toml",
"chars": 149,
"preview": "[env]\nCLIENT_PROCESS_NAME = \"trunk\"\n\n[tasks.build]\ncommand = \"trunk\"\nargs = [\"build\"]\n\n[tasks.start-client]\nscript = '''"
},
{
"path": "examples/cargo-make/wasm-test.toml",
"chars": 178,
"preview": "[tasks.post-test]\ndependencies = [\"test-wasm\"]\n\n[tasks.test-wasm]\nenv = { CARGO_MAKE_WASM_TEST_ARGS = \"--headless --chro"
},
{
"path": "examples/cargo-make/webdriver.toml",
"chars": 743,
"preview": "[tasks.start-webdriver]\nscript = '''\n BOLD=\"\\e[1m\"\n GREEN=\"\\e[0;32m\"\n RED=\"\\e[0;31m\"\n RESET=\"\\e[0m\"\n\n if command -v"
},
{
"path": "examples/counter/Cargo.toml",
"chars": 419,
"preview": "[package]\nname = \"counter\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[profile.release]\nopt-level = 'z'\ncodegen-units = 1\nlto ="
},
{
"path": "examples/counter/Makefile.toml",
"chars": 152,
"preview": "extend = [\n { path = \"../cargo-make/main.toml\" },\n { path = \"../cargo-make/wasm-test.toml\" },\n { path = \"../car"
},
{
"path": "examples/counter/README.md",
"chars": 270,
"preview": "# Leptos Counter Example\n\nThis example creates a simple counter in a client side rendered app with Rust and WASM!\n\n## Ge"
},
{
"path": "examples/counter/index.html",
"chars": 199,
"preview": "<!doctype html>\n<html>\n <head>\n <link data-trunk rel=\"rust\" data-wasm-opt=\"z\" />\n <link data-trunk rel=\"icon\" typ"
},
{
"path": "examples/counter/rust-toolchain.toml",
"chars": 49,
"preview": "[toolchain]\ntargets = [\"wasm32-unknown-unknown\"]\n"
},
{
"path": "examples/counter/src/lib.rs",
"chars": 734,
"preview": "use leptos::prelude::*;\n\n/// A simple counter component.\n///\n/// You can use doc comments like this to document your com"
},
{
"path": "examples/counter/src/main.rs",
"chars": 258,
"preview": "use counter::SimpleCounter;\nuse leptos::prelude::*;\n\npub fn main() {\n _ = console_log::init_with_level(log::Level::De"
},
{
"path": "examples/counter/tests/web.rs",
"chars": 5356,
"preview": "#![allow(dead_code)]\n\nuse counter::*;\nuse leptos::{mount::mount_to, prelude::*, task::tick};\nuse wasm_bindgen::JsCast;\nu"
},
{
"path": "examples/counter_isomorphic/.gitignore",
"chars": 11,
"preview": ".leptos.kdl"
},
{
"path": "examples/counter_isomorphic/Cargo.toml",
"chars": 3267,
"preview": "[package]\nname = \"counter_isomorphic\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[lib]\ncrate-type = [\"cdylib\", \"rlib\"]\n\n[profil"
},
{
"path": "examples/counter_isomorphic/LICENSE",
"chars": 1070,
"preview": "MIT License\n\nCopyright (c) 2022 Greg Johnston\n\nPermission is hereby granted, free of charge, to any person obtaining a c"
},
{
"path": "examples/counter_isomorphic/Makefile.toml",
"chars": 156,
"preview": "extend = [\n { path = \"../cargo-make/main.toml\" },\n { path = \"../cargo-make/cargo-leptos.toml\" },\n]\n\n[env]\n\nCLIENT_"
},
{
"path": "examples/counter_isomorphic/README.md",
"chars": 326,
"preview": "# Leptos Counter Isomorphic Example\n\nThis example demonstrates how to use a function isomorphically, to run a server sid"
},
{
"path": "examples/counter_isomorphic/src/counters.rs",
"chars": 8207,
"preview": "use leptos::prelude::*;\nuse leptos_router::{\n components::{FlatRoutes, Route, Router, A},\n StaticSegment,\n};\n#[cfg"
},
{
"path": "examples/counter_isomorphic/src/lib.rs",
"chars": 286,
"preview": "pub mod counters;\n\n#[cfg(feature = \"hydrate\")]\n#[wasm_bindgen::prelude::wasm_bindgen]\npub fn hydrate() {\n use crate::"
},
{
"path": "examples/counter_isomorphic/src/main.rs",
"chars": 2398,
"preview": "mod counters;\n\nuse crate::counters::*;\nuse actix_files::Files;\nuse actix_web::*;\nuse leptos_actix::{generate_route_list,"
},
{
"path": "examples/counter_url_query/Cargo.toml",
"chars": 375,
"preview": "[package]\nname = \"counter_url_query\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[profile.release]\ncodegen-units = 1\nlto = true\n"
},
{
"path": "examples/counter_url_query/Makefile.toml",
"chars": 105,
"preview": "extend = [\n { path = \"../cargo-make/main.toml\" },\n { path = \"../cargo-make/trunk_server.toml\" },\n]\n"
},
{
"path": "examples/counter_url_query/README.md",
"chars": 292,
"preview": "# Leptos Query Counter Example\n\nThis example creates a simple counter whose state is persisted and synced in the url wit"
},
{
"path": "examples/counter_url_query/index.html",
"chars": 188,
"preview": "<!DOCTYPE html>\n<html>\n\t<head>\n\t\t<link data-trunk rel=\"rust\" data-wasm-opt=\"z\"/>\n\t\t<link data-trunk rel=\"icon\" type=\"ima"
},
{
"path": "examples/counter_url_query/rust-toolchain.toml",
"chars": 49,
"preview": "[toolchain]\ntargets = [\"wasm32-unknown-unknown\"]\n"
},
{
"path": "examples/counter_url_query/src/lib.rs",
"chars": 1209,
"preview": "use leptos::prelude::*;\nuse leptos_router::hooks::query_signal;\n\n/// A simple counter component.\n///\n/// You can use doc"
},
{
"path": "examples/counter_url_query/src/main.rs",
"chars": 319,
"preview": "use counter_url_query::SimpleQueryCounter;\nuse leptos::prelude::*;\nuse leptos_router::components::Router;\n\npub fn main()"
},
{
"path": "examples/counter_without_macros/Cargo.toml",
"chars": 456,
"preview": "[package]\nname = \"counter_without_macros\"\nversion = \"0.1.0\"\nedition = \"2021\"\nrust-version = \"1.75\"\n\n[profile.release]\nco"
},
{
"path": "examples/counter_without_macros/Makefile.toml",
"chars": 355,
"preview": "extend = [\n { path = \"../cargo-make/main.toml\" },\n { path = \"../cargo-make/wasm-test.toml\" },\n { path = \"../cargo-mak"
},
{
"path": "examples/counter_without_macros/README.md",
"chars": 299,
"preview": "# Leptos Counter Example\n\nThis example is the same like the `counter` but it's written without using macros and can be b"
},
{
"path": "examples/counter_without_macros/index.html",
"chars": 188,
"preview": "<!DOCTYPE html>\n<html>\n\t<head>\n\t\t<link data-trunk rel=\"rust\" data-wasm-opt=\"z\"/>\n\t\t<link data-trunk rel=\"icon\" type=\"ima"
},
{
"path": "examples/counter_without_macros/src/lib.rs",
"chars": 1977,
"preview": "use leptos::{\n ev,\n html::{button, div, span},\n prelude::*,\n};\n\n/// A simple counter view.\n// A component is re"
},
{
"path": "examples/counter_without_macros/src/main.rs",
"chars": 170,
"preview": "use counter_without_macros::counter;\n\n/// Show the counter\npub fn main() {\n console_error_panic_hook::set_once();\n "
},
{
"path": "examples/counter_without_macros/tests/business.rs",
"chars": 1231,
"preview": "mod count {\n use counter_without_macros::Count;\n use pretty_assertions::assert_eq;\n use rstest::rstest;\n\n #["
},
{
"path": "examples/counter_without_macros/tests/web.rs",
"chars": 1833,
"preview": "#![allow(dead_code)]\n\nuse counter_without_macros::counter;\nuse leptos::{prelude::*, task::tick};\nuse pretty_assertions::"
},
{
"path": "examples/counters/.gitignore",
"chars": 117,
"preview": "# Support playwright testing\nnode_modules/\ntest-results/\nend2end/playwright-report/\nplaywright/.cache/\npnpm-lock.yaml"
}
]
// ... and 1158 more files (download for full content)
About this extraction
This page contains the full source code of the leptos-rs/leptos GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1358 files (4.6 MB), approximately 1.3M tokens, and a symbol index with 8394 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.