yewstack/yew

This system is the Yew framework, a Rust-based tool for building WebAssembly-powered web applications. It provides a component-based architecture supporting both traditional struct-based components and modern function components with hooks, enabling declarative UI development. The framework includes built-in capabilities for client-side routing, state management via contexts, and server-side rendering with hydration support. Additionally, it offers utilities for web workers, accessibility lints, and performance benchmarking to facilitate robust web development.

66 changes.

This period focused on a major architectural overhaul of the Yew framework, introducing a modern function-based component model with hooks and comprehensive Server-Side Rendering support. The core virtual DOM, macro system, and router were rewritten to support these new patterns, while legacy struct-based APIs were deprecated. The release was accompanied by an extensive suite of new examples and documentation to guide users through the migration.

35 changes.

This period focused on implementing the new Function Components and Hooks V2 system, including a complete rewrite of the macro and internal DOM reconciliation engine. It also introduced comprehensive server-side rendering (SSR) and hydration capabilities, supported by new hooks and benchmarking tools. The work was accompanied by extensive documentation updates and example applications demonstrating these modern patterns.

24 changes.

This period focused on the release of Yew versions 0.21 through 0.23, characterized by extensive documentation updates, migration guides, and the introduction of the yew-link crate for unified server-side rendering data fetching. The work also included significant infrastructure improvements such as automated build tools, SSR end-to-end testing, and the rewrite of the agent macro API to support new asynchronous patterns.

Introduces a new Boids flocking simulation example that renders individual boids as SVG polygons to demonstrate Yew's virtual DOM performance without using the Canvas API. The example includes a settings panel with sliders for parameters like cohesion, separation, and alignment, and persists user preferences to local storage. It is built with Trunk and configured to use wasm-opt version 129.

examples/boids · high confidence

A new example application has been added to the examples/contexts directory to demonstrate the Yew Context API. It showcases how components can communicate via a shared context rather than traditional component links, featuring both function components and struct-based components that consume and produce context state.

examples/contexts · high confidence

A new Counter example has been added to the examples directory, providing a simple interactive demo where users can increment or decrement a counter value using buttons. The implementation showcases the Yew component model by defining a \Msg\ enum for handling \Increment\, \Decrement\, and batched messages, updating internal state, and triggering re-renders. The example includes a Trunk configuration file that sets \wasm-opt\ to version 129, an HTML entry point, and SCSS styles for the UI layout.

examples/counter · high confidence

A new example application demonstrating the use of Yew's function components has been added to the examples directory. This TodoMVC implementation showcases modern Yew patterns, including state management via \use\_reducer\, side effects with \use\_effect\_with\, and component composition using the \html!\ macro. It serves as a reference for building interactive UIs with function-based components rather than the older struct-based approach.

_examples/function\_todomvc, examples/function\todomvc/src · high confidence

Introduces a new Memory Game example built with Yew function components and hooks, featuring persistent state via gloo storage and asynchronous callbacks. The example includes a complete responsive UI with SCSS styling for the game board, cards, and score panels, along with a Trunk configuration that sets wasm-opt to version\_129 for optimized builds.

_examples/function\_memory\game · high confidence

The Function Router example now includes a set of UI components for rendering a blog-style interface. This adds an author card that displays profile details and links to author pages, a navigation bar with dropdown menus for routing, a pagination system with previous/next buttons and page links, a post card displaying titles and author information, and a progress delay component that visualizes timed operations using a reducer and interval timer.

(repo-wide) · high confidence

A new example application has been added to \examples/node\_refs\ that demonstrates how to use node references to directly access and manipulate DOM elements. The example features a form with email and password inputs where the first field is automatically focused on mount, and any input field gains focus when the user hovers over it. It also includes basic client-side validation logic for the input fields.

_examples/node\refs · high confidence

The TodoMVC example has been added to the examples directory, providing a complete implementation of the TodoMVC standard using the Yew framework. This example introduces local storage persistence via \gloo\_storage\, ensuring that user data (entries, filter state, and edit values) is saved and restored across sessions. It also demonstrates advanced UI patterns such as DOM manipulation using \NodeRef\ for auto-focusing input fields, hash-based routing for filters, and handling keyboard events for adding and editing todos.

examples/todomvc · high confidence

A new WebGL example has been added to the examples directory, showcasing how to initialize a WebGL context, create a render loop, and draw to a canvas using basic shaders via the \web-sys\ crate. The example includes a Yew component that accesses the DOM element using \NodeRef\, sets up vertex and fragment shaders, and manages an animation frame loop. It is configured to run with the Trunk development server and uses \wasm-opt\ version 129 for optimization.

examples/webgl · high confidence

The \examples/function\_todomvc/src/hooks\ directory now includes a new \use\_bool\_toggle\ hook. This utility allows components to toggle a boolean value and trigger a single re-render with the new state, which automatically resets to the default value after that render cycle completes. This is useful for transient UI interactions, such as button click feedback, where the final state should not persist in the component's long-term state.

_examples/function\todomvc/src/hooks · high confidence

The documentation site now includes new guides for the 'more' section, covering CSS integration options (including component libraries and styling solutions), debugging techniques (console logging with tracing-web, gloo-console, and wasm-logger, plus source maps), deployment strategies (server configuration for SPAs, MIME types, and relative paths), the project roadmap, and application testing (snapshot testing and wasm\_bindgen\_test).

_website/versioned\docs/version-0.21/more · high confidence

The documentation site now includes versioned guides for Yew 0.20's function component hooks, covering the introduction of hook rules and pre-defined hooks (such as \use\_state\, \use\_effect\, and \use\_context\) as well as a guide on defining custom hooks with the \\#\[hook\]\ attribute.

_website/versioned\docs/version-0.20/concepts/function-components/hooks · high confidence

A new example application has been added to the examples/function\_delayed\_input directory that demonstrates how to implement delayed input processing for search fields. The example uses gloo-timers to debounce user input, sending requests to a backend only after the user has stopped typing for one second, rather than on every keystroke. It also simulates network latency using gloo\_timers::future::sleep to show how the UI handles fetching and fetched states.

_examples/function\_delayed\input · high confidence

The documentation for version 0.22 now includes a complete set of guides for function components. This covers the core concepts of creating components with the \\#\[component\]\ attribute, managing data via Props (including default values), handling state with hooks like \use\_state\ and \use\_effect\, and passing callbacks or children between components. It also introduces custom hooks, generic components, and node references for direct DOM access.

_website/versioned\docs/version-0.22/concepts/function-components · high confidence

The function\_router example now demonstrates server-side rendering (SSR) with hydration. It introduces a \ServerApp\ component that accepts URL and query parameters to initialize the router state, enabling the application to render on the server and hydrate on the client. The example also includes a content generator using Markov chains for procedural text and a procedural image generator, providing a complete demo of routing, SSR, and dynamic content generation.

_examples/function\router/src · high confidence

Introduces a new example application demonstrating client-side routing in Yew using function components and the \yew-router\ crate. The example features a multi-page blog layout with mobile-friendly styling, automatic adaptation to deployment sub-paths via Trunk's \--public-url\ configuration, and content generation offloaded to a web worker for performance.

_examples/function\_memory\_game/src, examples/function\router · high confidence

This change introduces a new interactive memory-matching game example built with Yew's function components. The implementation includes an App component managing game state and timers, a Chessboard component for rendering the grid, and individual ChessboardCard components handling flip interactions. Supporting UI elements include a ScoreBoard displaying game progress and best scores, and a GameStatusBoard showing status and a 'Play again' button. The example demonstrates modern Yew patterns including use\_reducer, use\_state, use\_effect\_with, and callback handling for game logic.

_examples/function\_memory\game/src/components · high confidence

The \examples/futures\ directory now contains a new example application that fetches Yew's README file asynchronously using \web-sys\ and renders the resulting Markdown content to the page. The example demonstrates how to handle asynchronous fetch requests via \yewtil\'s \LinkFuture\ and shows how to manually construct \Html\ VNodes without using the \html!\ macro. It is configured to build with \wasm-opt\ version 129 and can be run locally using the Trunk development server.

examples/futures · high confidence

A new example located at examples/inner\_html has been added to demonstrate how to render unescaped HTML content. The example shows how to manually create Html nodes without using the html! macro by leveraging the new VNode::from\_html\_unchecked method and manipulating the DOM via web-sys. It includes a README explaining the concepts, a Trunk.toml configuration using wasm-opt version\_129, and source code that loads an HTML string constant and renders it directly.

_examples/inner\html · high confidence

A new example named 'mount\_point' has been added to the examples directory. It demonstrates how to take control of the mounting process by manually creating a DOM element and passing it to \yew::Renderer::with\_root\, rather than relying on the default \yew::start\_app\ behavior. The example also shows how to integrate with JavaScript APIs using \web-sys\ to create and render a canvas element alongside the Yew application.

_examples/mount\point · high confidence

The nested\_list example has been added to demonstrate creating components that accept specific child elements and communicating with non-parent components using WeakComponentLink. The example features a nested list structure where hovering over items, headers, or lists updates a display of the last hovered element, and includes a toggleable inactive state for list headers.

_examples/nested\list · high confidence

A new example application has been added to demonstrate controlled components in Yew. It allows users to enter a password to see a strength estimate (using the zxcvbn library) or generate a random password. The implementation includes a custom controlled text input component, integration with js\_sys for random number generation, and styling via SCSS.

_examples/password\strength · high confidence

The router example has been added to the examples directory, demonstrating how to use yew-router for multi-page navigation. A key behavioral feature is its support for hosting at non-root paths (e.g., /router); it automatically detects the \--public-url\ value passed to Trunk via a \\<base data-trunk-public-url /\>\ tag in index.html, allowing the application to adapt its routing correctly regardless of the deployment prefix. The example also includes specific CSS styles for the burger menu and hero backgrounds, and uses wasm-opt version 129 for optimization.

examples/router · high confidence

The repository now includes a new timer example in the \examples/timer\ directory. This application demonstrates how to use \gloo\_timer\ for managing timeouts and intervals, as well as \gloo\_console\ for logging and timing operations. It serves as a technical demonstration of these concepts, featuring a UI with buttons to start/cancel timers and display elapsed time and log messages.

examples/timer · high confidence

A new example application has been added to demonstrate how to use timeouts and intervals within Yew function components. The app utilizes \gloo\_timer\ for scheduling and \use\_reducer\ for state management, providing a technical demonstration of these concepts.

_examples/timer\functional · high confidence

A new Rust utility in \tools/process-benchmark-results\ has been added to process benchmark data. It reads JSON output from the \js-framework-benchmark\ suite via standard input, transforms the raw results (specifically extracting median values for CPU or default types) into a format compatible with the \continuous-benchmark\ GitHub Action, and writes the structured JSON to standard output.

tools/process-benchmark-results · high confidence

The API documentation now displays a prominent banner at the top of the page when viewing documentation for an unreleased version of Yew Next. This header includes a message directing users to the latest stable documentation on docs.rs and is styled to be visible on both desktop and mobile devices, with specific adjustments for dark mode and smaller screen widths.

api-docs · high confidence

New documentation pages for version 0.22 have been added to the website, covering the introduction, editor setup, building a sample app, and available examples. These pages provide updated instructions for setting up the Yew development environment, including the new MSRV of 1.84.0, and offer specific code snippets and configuration guides for JetBrains IDEs, VS Code, and Neovim to help users start building applications immediately.

_website/versioned\docs/version-0.22/getting-started · high confidence

A new benchmarking utility has been added at tools/benchmark-ssr to measure server-side rendering performance. It includes benchmarks for basic rendering, routing, nested providers, and concurrent tasks, with support for configurable rounds, JSON output, and optional jemalloc allocation on Unix systems.

tools/benchmark-ssr · high confidence

The simple\_ssr example now includes a complete server-side rendering setup with client-side hydration support. Users can build the hydration bundle using Trunk and run the server to see the example in action. Additionally, end-to-end tests have been added to verify that the hydration process correctly restores the application state, ensuring that the server-rendered content matches the hydrated client-side output.

_examples/simple\ssr · high confidence

The versioned documentation for Yew 0.21 now includes a comprehensive tutorial that guides users through building a web application using Rust and WebAssembly. The guide covers setting up the development environment with Rust and Trunk, configuring the project to use the \csr\ feature, and creating a basic 'Hello World' component. It further details how to build HTML structures using Yew's \html!\ macro and explains the differences between standard HTML and Yew's syntax, such as expression wrapping and root node requirements.

_website/versioned\_docs/version-0.20/concepts/basic-web-technologies, website/versioned\_docs/version-0.20/concepts/function-components, website/versioned\docs/version-0.21/tutorial · high confidence

A new benchmark tool has been added to the repository to measure Yew's performance against the standard js-framework-benchmark suite. This change introduces the core Rust source code (lib.rs) implementing the benchmark's UI logic using Yew components, along with the necessary HTML entry point, configuration files, and documentation. It provides a concrete implementation for running performance tests on unreleased Yew versions.

tools/benchmark-struct · high confidence

The tools/benchmark-hooks directory now contains a complete implementation of the js-framework-benchmark hooks test suite using the Yew framework. This includes the application logic for managing row data, state actions (add, update, remove, swap, clear), and the necessary build configuration files to run the benchmark.

tools/benchmark-hooks · high confidence

The \html!\ macro now includes basic lints to catch common accessibility issues. When the \yew\_lints\ feature is enabled, the macro emits warnings if an \\<a\>\ tag lacks an \href\ attribute or uses a placeholder value like \\#\ or \javascript:void(0)\, and if an \\<img\>\ tag is missing an \alt\ attribute. These checks help ensure that assistive technologies can correctly interpret links and images.

_packages/yew-macro/src/html\tree/lint · high confidence

The documentation site now includes a new 'Advanced Topics' section for version 0.20, covering core component concepts and patterns. This includes guides on struct component lifecycle (create, view, rendered, update), property handling with derive macros, and communication via callbacks and refs. It also introduces advanced patterns such as typed and enum-typed children, higher-order components, portals for rendering outside the DOM hierarchy, and server-side rendering with hydration support. Additionally, performance optimization strategies like smart pointers, pure components, and binary size reduction are documented.

_website/versioned\docs/version-0.20/advanced-topics · high confidence

The website now includes a central index and detailed migration guides for upgrading the Yew, yew-agent, and yew-router packages. These guides document breaking changes and provide step-by-step instructions for specific version jumps, such as the yew-agent separation from yew, the yew-router API rewrite, and significant updates to the Yew framework including the new Hooks API, automatic message batching, the \\#\[component\]\ attribute rename, and MSRV increases to Rust 1.84.0.

website/migration-guides · high confidence

The CI pipeline now automatically measures and reports bundle sizes and server-side rendering (SSR) performance for pull requests. New scripts collect example distribution sizes, compare them against the master branch to highlight significant changes, and format SSR benchmark results into GitHub comments, providing developers with immediate feedback on code impact.

ci · high confidence

A new binary tool has been added to the build-examples suite that automatically detects and updates the wasm-opt version in the Trunk.toml configuration files of the project's examples. This tool scans the examples directory, identifies those with outdated or missing wasm-opt settings, and updates them to the latest available version, ensuring consistent optimization levels across the example projects.

tools/build-examples/src/bin · high confidence

A new example application has been added to show how to dynamically create and destroy Yew app instances at runtime. The app uses a main component to manage a collection of child CounterModel instances, mounting them into the DOM via \yew::Renderer::with\_root\_and\_props\ and unmounting them using the \AppHandle::destroy\ method when triggered by user interaction.

_examples/dyn\_create\_destroy\apps · high confidence

A new example application has been added to showcase the usage of immutable types (IString, IArray, IMap) from the implicit-clone library within Yew. The demo includes interactive components for managing a list of names (IArray), a key-value store (IMap), and a single text value (IString), allowing users to see how these immutable structures integrate with Yew's component model and state management.

examples/immutable · high confidence

Adds a new \suspense\ module to Yew, enabling components to suspend rendering while waiting for asynchronous tasks to complete. This includes a \Suspense\ component that displays a fallback UI during suspension, and hooks like \use\_future\ and \use\_future\_with\ that allow components to await futures and suspend until results are ready. The implementation handles suspension state, hydration, and deferred rendering to ensure consistent UI updates.

packages/yew/src/suspense · high confidence

A new changelog generation tool has been added to the \tools/changelog\ directory, providing an automated way to produce release notes for Yew packages (Yew, YewAgent, YewRouter, and YewLink). The tool analyzes git history between tags, fetches GitHub issue labels and author details via the GitHub API, and categorizes changes into Fixes, Features, and Breaking Changes. It supports generating both a file-based changelog (appending to the existing \CHANGELOG.md\) and a formatted summary for GitHub release tags, with configurable version bumping and optional authentication for API rate limits.

tools/changelog · high confidence

This change adds two new functional hooks, \use\_prepared\_state\ and \use\_transitive\_state\, to the Yew framework to support server-side rendering (SSR) and hydration workflows. \use\_prepared\_state\ allows components to receive state prepared on the server and hydrated on the client, while \use\_transitive\_state\ enables state creation that depends on server-side artifacts. The implementation includes feature-gated variants for SSR, hydration, and combined modes, utilizing \bincode\ for serialization and \base64\ encoding to transmit state between server and client. These hooks return a \SuspensionResult\ to handle the asynchronous nature of hydration and ensure consistent state across rendering environments.

_packages/yew/src/functional/hooks/use\_prepared\state · high confidence

The \packages/yew/src/functional\ module has been added to support a new function-based component model. Users can now define components using the \\#\[component\]\ attribute macro, which simplifies component creation compared to the previous struct-based approach. This module also introduces a hooks system (exposed via \pub use hooks::\*\), allowing functional components to manage state and side effects through primitives like \next\_state\ and \next\_effect\ within a \HookContext\. The old \function\_component\ macro is re-exported as \component\ for compatibility, with the former name marked as deprecated since version 0.22.0.

packages/yew/src/functional · high confidence

This change introduces the new \\#\[component\]\ and \\#\[hook\]\ macros along with a comprehensive set of built-in hooks (\use\_state\, \use\_reducer\, \use\_effect\, \use\_callback\, \use\_memo\, \use\_context\, \use\_ref\, \use\_force\_update\, \use\_prepared\_state\, and \use\_transitive\_state\). For users, this provides a modern, React-like API for building Yew applications, enabling declarative component definitions, persistent state management, side-effect handling, and memoization directly within function components.

packages/yew/src/functional/hooks · high confidence

Added Japanese (ja) translations for the documentation website, including UI strings for the Docusaurus theme, blog, and community docs, as well as translated content for the migration guides (yew, yew-agent, yew-router) and advanced topics such as server-side rendering, portals, and struct components.

website/i18n · high confidence

The js\_callback example now demonstrates how to dynamically import JavaScript modules at runtime using wasm-bindgen and Trunk. It includes a Trunk configuration that runs a post-build hook to inject the snippets directory path into the HTML, allowing the Rust application to lazy-load external JS files (such as \unimp.js\) via dynamic imports while keeping initial imports (like \imp.js\) bundled statically.

_examples/js\callback · high confidence

Added a new set of documentation pages for the \html!\ macro in the Yew 0.20 versioned docs. These pages cover core concepts including classes, components, conditional rendering, elements, events, fragments, lists, and literals, providing users with updated examples and explanations for building declarative HTML and SVG in Yew.

_website/versioned\docs/version-0.20/concepts/html · high confidence

Added a new set of documentation pages under the HTML concepts section for version 0.22, covering the \html!\ macro's core features. These pages explain how to use classes, define components with properties and children, render conditionally, handle events, create fragments, iterate over lists, and manage literals and expressions.

_website/versioned\docs/version-0.22/concepts/html · high confidence

The \packages/yew/src/html/conversion\ module now introduces the \IntoPropValue\ trait, enabling automatic conversion of various types into component properties. This allows developers to pass raw values, references, \Option\ wrappers, closures, and child components directly to props without explicit wrapping, simplifying component usage by handling conversions to \VNode\, \Callback\, and \ChildrenRenderer\ internally.

packages/yew/src/html/conversion · high confidence

The router now exposes \Link\ and \Redirect\ components in \packages/yew-router/src/components\. The \Link\ component renders an anchor tag that handles navigation via the navigator, supporting query parameters, route state, and modifier-key overrides (meta/ctrl/shift/alt) to preserve default browser behavior. The \Redirect\ component automatically pushes a target route to the history when rendered. These components provide a declarative way to handle navigation and redirection within Yew applications.

packages/yew-router/src/components · high confidence

A new example application has been added to the examples/portals directory that demonstrates how to use Yew's \create\_portal\ function to render elements into arbitrary DOM nodes outside the main component tree. The example showcases two specific use cases: injecting a \\<style\>\ tag directly into the document \\<head\>\ and rendering content into a Shadow DOM host element, illustrating manual DOM manipulation via \web-sys\ and the creation of \Html\ without the \html!\ macro.

examples/portals · high confidence

A new \ssr-e2e\ tool has been added to automate end-to-end testing of Server-Side Rendering scenarios. The harness manages the test lifecycle by building the Trunk project, starting the SSR server, waiting for it to become healthy, and then executing the specified Cargo test package. It provides a shared test library (\ssr-e2e-harness\) that allows tests to fetch pre-rendered HTML from the server, inject it into the browser, hydrate the application, and verify that client-side navigation behaves correctly (e.g., ensuring no redundant network requests are made during hydration).

tools/ssr-e2e · high confidence

Added \actix\_ssr\_router\ and \axum\_ssr\_router\ examples that demonstrate server-side rendering with hydration. These examples integrate the \yew-link\ crate to provide a unified approach for fetching linked state data across both server-side rendering (SSR) and client-side rendering (CSR) contexts, ensuring consistent data handling during navigation and hydration.

_examples/actix\_ssr\_router, examples/axum\_ssr\router · high confidence

A new example application has been added to \examples/suspense\ that demonstrates how to use Yew's \\<Suspense /\>\ component. It showcases two distinct patterns: one using a function component (\AppContent\) and another using a struct-based component (\struct\_consumer::AppContent\), both utilizing a custom \use\_sleep\ hook to simulate asynchronous loading. The example includes a UI with a text area and a 'Take a break!' button to trigger suspension, allowing users to see how fallback UIs are rendered while content is pending.

examples/suspense · high confidence

Added a new example demonstrating server-side rendering (SSR) using the WASI target. This example shows how to build and run a Yew application that renders HTML on the server side using wasmtime's WASI preview2, including routing setup and basic page content.

_examples/wasi\_ssr\module · high confidence

The \yew-macro\ crate now includes a new \props!\ macro and a refactored prop-parsing system that allows users to programmatically construct component properties. This change introduces \ComponentProps\ and \ElementProps\ structs to handle component and HTML element attributes separately, supporting dynamic prop labels, shorthand syntax, and explicit handling of boolean attributes and event listeners. Users can now generate props at runtime using the \props!\ macro, which accepts a type and a list of key-value pairs, enabling more flexible and dynamic component composition.

packages/yew-macro/src/props · high confidence

Added the \async\_clock\ example, which demonstrates asynchronous coding in Yew components. The app runs a background clock, fetches online jokes every 10 seconds, and computes a 'fun score' based on joke length. It showcases key async features including \send\_future\, \send\_stream\, \spawn\_local\, and \mpsc::unbounded\ channels, and is configured to use wasm-opt version 129.

_examples/async\clock · high confidence

A new Rust-based build-examples tool has been added to the repository. It iterates through the examples directory, builds each example using Trunk, and validates the output for undefined symbols. Additionally, it checks the wasm\_opt version configured in each example's Trunk.toml against the latest release from the WebAssembly binaryen GitHub API, emitting warnings for any outdated configurations.

tools/build-examples/src · high confidence

The website now includes dedicated community pages: \awesome.md\ provides a curated list of community-built projects, templates, crates (component libraries, hooks, utilities), tooling, articles, and books related to Yew, while \external-libs.mdx\ highlights specific external libraries like Malvolio, weblog, and Gloo that assist with Yew development.

website/community · high confidence

The version 0.20 documentation now includes dedicated concept pages for Agents (offloading tasks to web workers), Contexts (passing data through the component tree), the Router (handling URLs and navigation), and Suspense (suspending rendering during data fetching). These pages provide usage examples, lifecycle diagrams, and integration details for these core Yew features.

_website/versioned\docs/version-0.20/concepts · high confidence

Added new documentation pages for version 0.22 covering the \html!\ macro, the \classes!\ macro for CSS styling, and integration with JavaScript via \wasm-bindgen\, \js-sys\, and \web-sys\. These pages explain how to embed Rust values in HTML, manage CSS classes programmatically, and bridge Rust to JavaScript using WebAssembly bindings.

_website/versioned\_docs/version-0.20/getting-started, website/versioned\_docs/version-0.21/concepts/basic-web-technologies, website/versioned\docs/version-0.22/concepts/basic-web-technologies · high confidence

The documentation for version 0.21 now includes a comprehensive guide to function components, covering core concepts such as properties (props), state management, and communication patterns like callbacks and children. It also introduces a dedicated section on hooks, detailing the rules for using built-in hooks (such as \use\_state\, \use\_effect\, and \use\_memo\) and providing examples for creating custom hooks to encapsulate reusable stateful logic.

_website/versioned\docs/version-0.21/concepts/function-components · high confidence

The versioned documentation site for version 0.21 now includes new concept pages covering Agents, Contexts, HTML (including classes, components, conditional rendering, elements, events, fragments, lists, and literals), Router, and Suspense. These pages provide usage examples and explanations for these features in the Yew framework.

_website/versioned\docs/version-0.21/concepts/html · high confidence

The version 0.22 documentation now includes dedicated pages for CSS integration, debugging techniques, deployment strategies, application testing, and the project roadmap. The CSS page lists community styling solutions and component libraries. The debugging page recommends \tracing-web\ and \gloo-console\ for console logging while noting \wasm-logger\ is unmaintained. The deployment page provides guidance on server configuration, MIME types for WebAssembly, and relative paths. The testing page introduces snapshot testing and \wasm\_bindgen\_test\. The roadmap page outlines current focuses such as functional components and production readiness.

_website/versioned\_docs/version-0.20/more, website/versioned\docs/version-0.22/more · high confidence

Added the \two\_apps\ example, which illustrates how to manually control the mounting process using \yew::Renderer\ instead of the default \start\_app\. The example mounts two separate Yew app instances into distinct DOM elements and enables them to communicate by exchanging messages through their respective \AppHandle\ scopes.

_examples/two\apps · high confidence

Added three new examples to the examples directory: \communication\_child\_to\_parent\ shows updating a parent from children using callbacks; \communication\_grandchild\_with\_grandparent\ demonstrates bidirectional communication between grandchildren and a grandparent using the context API; and \communication\_grandparent\_to\_grandchild\ illustrates passing state from a grandparent to a grandchild via ContextProvider. Each example includes a README, Trunk configuration, HTML entry point, SCSS styles, and Rust source files for the component hierarchy.

_examples/communication\_grandchild\_with\grandparent · high confidence

Added a new file upload example that demonstrates reading files in Yew using gloo::file. The example supports both file selection and drag-and-drop, allowing users to upload images and videos which are then rendered as previews on the page. It includes a styled UI with a drop zone and preview tiles, configured to run via the Trunk development server with wasm-opt version 129.

_examples/file\upload · high confidence

Added a new example in the \examples/keyed\_list\ directory that demonstrates how using keyed elements improves the performance of comparing changes to lists. The example allows users to manipulate a list of persons (create, delete, sort, swap, reverse) and toggle between keyed and non-keyed rendering to observe the difference in DOM update times, which are displayed on the page. It includes a configuration to use \wasm-opt\ version 129 and requires specific RUSTFLAGS for the wasm\_js backend.

_examples/keyed\list · high confidence

Added a new Rust-based CLI tool at tools/collect-release-info that automates the generation of release notes for multi-package repositories. The tool identifies the latest git tag for specified packages, extracts the corresponding changelog sections, converts Markdown links to GitHub-native mentions (e.g., @user, \#issue), and outputs structured JSON data for use in CI/CD workflows.

tools/collect-release-info · high confidence

The router example now includes four new components: AuthorCard and PostCard display generated content with links to specific routes, Pagination handles page navigation with query parameters, and ProgressDelay provides a timed progress bar using gloo timers.

examples/router/src/components · high confidence

Added a new server-side rendering example that fetches a random UUID from an external API during server execution. The component uses the \use\_prepared\_state\ hook to handle asynchronous data fetching and wraps the content in a \Suspense\ boundary to manage loading states, providing a concrete pattern for SSR data loading in Yew applications.

_examples/simple\ssr/src · high confidence

A new \utils\ module has been added to the Yew core library, introducing the \NodeSeq\ type to facilitate the flattening and conversion of component children and HTML nodes within the macro system. This addition includes helper functions like \into\_node\_iter\ for iterator transformation, \print\_node\ for debugging DOM elements, and internal traits like \RcExt\ to support efficient reference counting operations, thereby improving how nested HTML structures are processed and rendered.

packages/yew/src/utils · high confidence

A new \tools/website-test\ crate has been added to the repository. It includes a \build.rs\ script that scans documentation files for Rust code blocks, applies diffs where specified, and generates a \website\_tests.rs\ file containing these examples as \no\_run\ tests. This enables automated testing of code snippets found in the project's documentation to ensure they remain valid.

tools/website-test · high confidence

This change introduces the \yew-link\ crate and its accompanying \yew-link-macro\ to enable unified data fetching across server-side rendering (SSR) and client-side rendering (CSR). Developers can now use the \\#\[linked\_state\]\ macro to define state types that automatically implement server-side resolution logic (stripped from WASM bundles) and client-side fetching via a \Resolver\ registry. The crate provides a \LinkedStateHandle\ for accessing resolved data with stale-while-revalidate semantics and includes optional integration handlers for Axum and Actix web frameworks to expose a \/api/link\ endpoint for transferring resolved state from server to client.

packages/yew-link, packages/yew-link-macro · high confidence

The documentation site now includes a new versioned set of guides for version 0.22 under the 'advanced-topics' and 'concepts' sections. This update adds comprehensive documentation for component patterns and internals, including how to handle children (typed and nested), server-side rendering (SSR) with suspense and hydration, portals for rendering outside the DOM hierarchy, and struct component lifecycles (create, view, rendered, update). It also covers performance optimizations using smart pointers, immutable types via the \implicit-clone\ crate, and architectural concepts like agents (web workers) and contexts for prop drilling avoidance.

_website/versioned\docs/version-0.22/advanced-topics · high confidence

The local implementation of the HTML rendering engine and application event loop has been removed from the source code. This eliminates the custom \stdweb\-based framework logic (including the \program\ entry point, \Tag\ rendering, and \OnClick\ event handling) that was previously defined in \src/main.rs\, effectively stripping the crate of its self-contained UI runtime capabilities.

src · high confidence

A new .nojekyll file has been added to the website/static directory. This file prevents static site generators like Jekyll from processing the directory, ensuring that static assets are served exactly as written without modification.

website/static · high confidence

The website's navigation bar now automatically adjusts the API documentation link based on the current documentation version. When viewing the 'next' version of the docs, the API button points to the nightly API reference (api.yew.rs/next/yew), while other versions link to the corresponding stable docs.rs release, ensuring users always access the API docs relevant to the version they are reading.

website/src/theme · high confidence

The \yew-agent-macro\ crate has been rewritten to support the new Agent v2 API, replacing the previous implementation with two new procedural macro attributes: \\#\[reactor\]\ and \\#\[oneshot\]\. The \reactor\ attribute allows users to define asynchronous agents that receive a scope for message handling, while the \oneshot\ attribute enables single-execution agents that take an input and return a result. This change introduces a new macro-based syntax for defining agent behavior, requiring users to update their agent definitions to use these new attributes instead of the legacy agent structure.

packages/yew-agent-macro · high confidence

The \html!\ macro parser has been completely rewritten to support Rust control flow keywords (\if\, \for\, \while\, \match\, \break\, \continue\, \return\) directly within the template syntax. This change introduces new parsing structures for these blocks, allowing developers to write conditional logic and loops inline without wrapping them in \html!\ calls or braces. The update also enforces stricter validation, such as treating \\<textarea\>\ as a void element that cannot have children, and adds deprecation warnings for legacy patterns like using \html!\ inside expression blocks.

_packages/yew-macro/src/html\tree · high confidence

The \yew-router-macro\ now uses the \matchit\ library for route matching instead of the previous \route-recognizer\. This change introduces a new syntax for route parameters: developers must now use curly braces (e.g., \\#\[at("/posts/{id}")\]\) instead of the old colon syntax (e.g., \:id\). The macro now validates route patterns at compile time, providing clear error messages if the old syntax is detected or if route parameters do not match the enum variant fields. It also rejects routes containing \\#\ characters, suggesting \HashRouter\ as an alternative for such cases.

packages/yew-router-macro/src · high confidence

The \packages/yew/src/dom\_bundle/btag\ module introduces a new internal bundle implementation (\BTag\) for handling \\<VTag\>\ reconciliation. This change refactors how Yew manages DOM elements by introducing dedicated modules for attributes (\attributes.rs\) and event listeners (\listeners.rs\). Key behavioral updates include applying attributes before inserting elements into the DOM to prevent issues with SVG animations, using a global registry for event listener management to support reentrant handlers, and ensuring \checked\ attributes are applied on every update for input elements to prevent browser state drift. The implementation also adds specific handling for \InputFields\ and \TextareaFields\, including proper value synchronization and hydration support.

_packages/yew/src/dom\bundle/btag · high confidence

The versioned documentation site for Yew 0.21 now includes a comprehensive set of new articles in the \advanced-topics\ section. These pages cover core component concepts such as struct component lifecycle, properties, callbacks, refs, and scope, as well as advanced patterns like Higher Order Components, portals, and immutable types. The documentation also explains low-level internals like the \html!\ macro and virtual DOM, and provides detailed guides on performance optimizations, server-side rendering (SSR) with hydration, and handling typed children.

_website/versioned\docs/version-0.21/advanced-topics · high confidence

The event handling system in \packages/yew/src/html/listener\ has been refactored to introduce a new macro-driven listener implementation. This change adds support for \focusin\ and \focusout\ events, which were previously missing, and ensures \onsubmit\ correctly uses the \SubmitEvent\ type. Additionally, the system now allows developers to pass plain functions (\Fn(EVENT)\) directly to event handlers, in addition to \Callback\ instances, simplifying the API for common use cases. The \IntoEventCallback\ trait facilitates this conversion, enabling more ergonomic event binding in components.

packages/yew/src/html/listener · high confidence

The \yew-macro\ crate now introduces the \\#\[component\]\ attribute for defining function components and the \\#\[hook\]\ attribute for creating custom hooks, replacing the previous \function\_component\ macro. It also adds \use\_prepared\_state\ and \use\_transitive\_state\ macros to manage component state with explicit dependency tracking, and a \classes\ macro to safely handle HTML class names with compile-time validation.

packages/yew-macro/src · high confidence

The \\#\[derive(Properties)\]\ implementation in \yew-macro\ has been refactored to use a new builder pattern that constructs props in alphabetical order and enforces that all required properties are set before the build completes. This change introduces a \PropsBuilder\ and a \PropsWrapper\ to manage field initialization, ensuring that missing required props result in clearer, more concise compile-time diagnostics. The new design also supports \Self\ in prop fields, const generics, and unit structs, while removing special handling for \Option\ types in derived properties to simplify the macro's behavior.

_packages/yew-macro/src/derive\props · high confidence

The website's home page has been completely rewritten to feature a new responsive design and a dedicated section highlighting key framework capabilities. The new layout includes a hero section with the site logo and title, prominent 'Get Started' and 'Playground' call-to-action buttons, and a grid-based feature list showcasing Component Based architecture, the HTML macro, and Server Side Rendering. The styling uses SCSS modules with media queries to ensure the layout adapts correctly across mobile, tablet, and desktop viewports.

website/src/pages · high confidence

The \packages/yew/src/html\ module has been restructured to improve performance and ergonomics. The \Classes\ type is now backed by \Rc\<IndexSet\>\ to make cloning cheap and reduce allocations, while \NodeRef\ has been reimplemented using \Rc\<RefCell\>\ to provide a more robust reference to DOM nodes. Additionally, the module now exports \RenderError\ and \HtmlResult\ types to support suspended rendering, and exposes the \create\_portal\ function for rendering children outside the main DOM hierarchy.

packages/yew/src/html · high confidence

The internal mechanism for managing the virtual DOM has been rewritten to use a new 'bundle' system (e.g., BComp, BList, BPortal, BTag) that explicitly tracks DOM positions via \DomSlot\ and \DynamicDomSlot\. This change introduces a new reconciliation path that handles attaching, shifting, and detaching nodes through these bundles, significantly altering how the framework manages component lifecycles, list diffing, and portal placement. It also adds support for hydration fragments, allowing the framework to correctly hydrate existing server-rendered content by collecting and managing DOM nodes in \Fragment\ structures.

_packages/yew/src/dom\bundle · high confidence

The website's documentation navigation has been reorganized into distinct sidebar files. The main docs sidebar now features a clearer hierarchy with 'Getting Started', 'Concepts' (including a dedicated section for Function Components and Hooks), 'Advanced topics', and 'More' (covering deployment, testing, and debugging). A new 'Community' sidebar has been introduced to automatically list community-related pages. Additionally, a dedicated 'Migration guides' sidebar has been added, providing structured access to version upgrade paths for yew, yew-agent, and yew-router.

website/sidebars · high confidence

The component system in \packages/yew/src/html/component\ has been significantly restructured to support advanced rendering modes and improved state management. This change introduces a new \ComponentRenderState\ enum that explicitly distinguishes between CSR, Hydration, and SSR states, enabling better handling of server-side rendering and hydration mismatches via the new \PhantomComponent\ marker. The \Context\ struct now includes \prepared\_state\ for SSR data passing, while the \Scope\ and \AnyScope\ APIs have been refined to support parent scope traversal and context providers more robustly. Additionally, the \Children\ and \Properties\ modules have been reorganized to provide clearer builders and type safety for component props and child elements.

packages/yew/src/html/component · high confidence

The router example's page components (home, author, post, post\_list, etc.) have been rewritten to use the new \html!\ macro syntax, including \for\ loops and inline expressions, and now feature procedurally generated content (authors, posts, images) driven by random seeds. This introduces dynamic, randomized views for the home, author list, and post pages, replacing the previous static or manually defined content structure.

examples/router/src/pages · high confidence

The \\#\[hook\]\ macro in \yew-macro\ has been completely rewritten to support the new Function Components & Hooks V2 system. This change introduces a new internal structure with dedicated modules for handling hook signatures, lifetime elision, and body rewriting. Specifically, the macro now enforces that hooks must be named with a \use\_\ prefix, cannot be async/const/unsafe/extern, and cannot be methods. It also implements stricter rules to prevent hooks from being called inside control flow branches (if/loop/match/while/closures), emitting a compile-time error if violated. The macro now automatically manages lifetimes for generic types and return values, ensuring proper integration with the \yew::functional::Hook\ trait.

packages/yew-macro/src/hook · high confidence

The router example has been updated to replace static placeholder data with a new content generation system. A new \generator\ module now uses the \lipsum\ crate's MarkovChain and \rand\_09\ for randomization to dynamically create posts, authors, and sections, while the \content\ module defines the data structures for this generated content. This change also updates the example to use \rand\_09\ and \function\_router::imagegen\ for generating image URLs, replacing the previous static image approach.

examples/router/src · high confidence

The simple\_ssr example now supports server-side rendering with streaming responses and client-side hydration. The server binary (simple\_ssr\_server.rs) uses Yew's ServerRenderer to stream rendered HTML chunks, wrapping them with static HTML parts, and serves this via a Warp-based HTTP server on localhost:8080. The client binary (simple\_ssr\_hydrate.rs) initializes tracing-web for logging in the browser and uses Yew's Renderer to hydrate the pre-rendered content. This replaces the previous non-streaming SSR approach and adds proper hydration capabilities to the example.

_examples/simple\ssr/src/bin · high confidence

The tutorial documentation has been updated to reflect the Yew 0.22 release, including the addition of the version selector entry and synchronization of content. The guide now instructs users to install the \trunk\ build tool and configure the \wasm32-unknown-unknown\ target, and it updates the \Cargo.toml\ dependency to specify \yew = { version = "0.22", features = \["csr"\] }\. Additionally, the tutorial content has been refreshed to correct outdated fetching data sections, update placeholder image generators, and fix grammar.

_website/versioned\docs/version-0.22/tutorial · medium confidence

The getting-started documentation has been refreshed to reflect the current state of the Yew framework. The minimum supported Rust version (MSRV) is now 1.76.0. The guide includes new instructions for setting up code editors (VS Code, JetBrains, Neovim) with specific snippets and extensions for Yew components. The 'Build a sample app' section provides updated steps for creating a project using either the \yew-trunk-minimal-template\ or manual setup, including a workaround for a Trunk bug on Windows. Additionally, the examples page now highlights live deployments available at examples.yew.rs.

_website/versioned\docs/version-0.21/getting-started · high confidence

The website's visual theme has been updated with new primary color values for both light and dark modes to enhance accessibility. The light mode primary color is now a darker green (\#00755a), while the dark mode primary color is a brighter teal (\#28d2ad), ensuring better contrast and readability for users.

website/src/css · high confidence

The versioned tutorial documentation for Yew 0.20 has been updated to reflect the current framework usage. This includes instructions for setting up the project with the \csr\ feature, using \trunk\ for the development server, and writing components with the \html!\ macro. The guide also covers basic HTML structure and styling for the sample 'RustConf Explorer' application.

_website/versioned\docs/version-0.20/tutorial · high confidence

The documentation for version 0.23 has been prepared and published, introducing new advanced topics such as component children, portals, server-side rendering, and struct component lifecycle. The release also includes updated tutorials, corrected asset links, and general polish to existing guides.

_website/versioned\docs/version-0.23 · high confidence

The virtual DOM module has been completely rewritten to introduce a new \Key\ type for efficient node identification, a \Listeners\ system for event handling, and dedicated virtual node types including \VPortal\ for DOM portaling, \VSuspense\ for suspendable rendering, and \VRaw\ for raw HTML injection. This change also adds comprehensive Server-Side Rendering (SSR) and hydration support, enabling components to be rendered to strings and reconnected to the client-side DOM, while introducing an \AttributeOrProperty\ distinction to bind values to DOM properties by default.

_packages/yew/src/virtual\dom · high confidence

The web\_worker\_fib and web\_worker\_prime examples have been rewritten to use the new yew-agent v2 API, replacing the previous agent patterns with OneshotProvider/ReactorProvider and corresponding hooks. Additionally, the build configuration in Trunk.toml has been updated to use wasm-opt version\_129 for both examples.

_examples/web\_worker\fib · high confidence

The documentation website has been rebuilt on Docusaurus v2, introducing a version selector that allows users to view documentation for specific releases (0.20 through 0.23) alongside the current 'next' version. To improve the developer experience, the site now features Rust syntax highlighting and automatically strips hidden \\#\ lines from Rust code blocks to match standard rustdoc output. Additionally, a custom remark plugin ensures that API links and dependency instructions in the docs automatically resolve to the correct version-specific URLs (e.g., docs.rs or the preview host) based on the selected documentation version.

website · high confidence

The Yew framework has released version 0.23.0, which includes a performance optimization where \use\_reducer\ now skips re-rendering for identical \Rc\ values (users can use \use\_force\_update\ if they need to force a re-render). The \html!\ macro now accepts \&str\ and \String\ for \Option\<Html\>\ props and allows bare \None\ values for \Option\<T\>\ props. A new \scheduler::flush\ function is available for reliably finishing rendering in tests. Additionally, the framework's scheduler now yields to the main thread periodically to improve web page responsiveness and reduce long-task warnings. The release also includes fixes for broken child re-renders and updates to \yew-router\ (0.20.0) and \yew-agent\ (0.5.0) to pin Yew to 0.23.

(repo-wide) · high confidence

The \yew-agent\ package has been restructured to vendor \gloo-workers\ and expose a new API surface for web workers. It now provides dedicated providers (\WorkerProvider\, \ReactorProvider\, \OneshotProvider\) and corresponding hooks (\use\_worker\_bridge\, \use\_reactor\_bridge\, \use\_oneshot\_runner\) to manage agent lifecycles. The module introduces a \Reach\ enum to control agent visibility (Public vs. Private) and adds a \reset\ capability to bridge handles, allowing users to disconnect and reconnect agents without unmounting components.

packages/yew-agent · high confidence

The \yew-router\ crate has been rewritten to provide a modern, hook-based API for Yew functional components, introducing \use\_navigator\, \use\_location\, and \use\_route\ hooks for accessing router state and navigation. Routing matching now uses the \matchit\ library instead of the previous \route-recognizer\, enabling support for named wildcards in route definitions. The router also supports dynamic basenames, allowing the base path to change at runtime, and integrates with \gloo-history\ for universal session history management.

packages/yew-router/src · high confidence

The Yew framework core has been significantly restructured to introduce a new application lifecycle and rendering model. The \Renderer\ now returns an \AppHandle\ that allows applications to be explicitly destroyed and their properties updated via \AppHandle::update\. A new \ContextHandle\ mechanism has been added to manage context subscriptions and unsubscriptions more robustly. The framework now supports Server-Side Rendering (SSR) with hydration capabilities through \LocalServerRenderer\ and \ServerRenderer\, including streamed rendering. The internal scheduler has been reworked to separate component creation, rendering, and destruction phases, and the platform abstraction now uses \tokise\ to support both WebAssembly and native runtimes.

packages/yew/src · high confidence

Added compile-fail and compile-pass tests for the props macro; Added compile-time tests for the Routable derive macro; Added compile-time validation tests for derive(Properties) macro; Added compile-time validation tests for function component attributes; Added compile-time validation tests for the Routable derive macro; Added compile-time validation tests for use\_prepared\_state and use\_transitive\_state hooks; Added comprehensive test coverage for Yew core features; Added comprehensive test suite for yew-router; Added integration tests for the Yew changelog generator; Added layout testing utilities for Yew components; Added macro test suites for classes, props, hooks, and HTML deprecation lints; Added test helper utilities for DOM element retrieval; Added tests for HTML macro linting; Added tests for hook macro edge cases and hygiene; Added vnode cloning benchmark; Expanded compile-time validation for the \html!\ macro.

All example projects and core Yew packages (yew, yew-router, yew-link, yew-agent, and their macro crates) have been updated to use the Rust 2024 edition. This change aligns the framework's demonstration code and internal components with the latest Rust language standards, ensuring compatibility with modern Rust tooling and compiler features.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 43 → 70 (+26.8)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 76 → 93 (+17.4)
• Architecture 69 → 100 (+30.7)
• Maturity 57 → 58 (+1.5)
• Readiness 28 → 85 (+56.9)
• Security 50 → 69 (+18.3)
• Event Sourcing 100 (new)

• Dimension evaluation failed
• High CVE: [GHSA redacted] (tools/benchmark-hooks/package-lock.json)
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (tools/benchmark-hooks/package-lock.json)
• High CVE: [GHSA redacted] (tools/benchmark-hooks/package-lock.json)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 59 more

• AHrefLint::lint (cognitive 17) (packages/yew-macro/src/html_tree/lint/mod.rs)
• BList::apply_keyed (cognitive 43) (packages/yew/src/dom_bundle/blist.rs)
• BList::apply_keyed (cyclomatic 20) (packages/yew/src/dom_bundle/blist.rs)
• Base-context workflow trigger runs with an unscoped token
• CI installs an unverified third-party binary (.github/workflows/main-checks.yml)
• Documentation: no project overview (examples/js_callback/README.md)
• Duplicated block (10 lines × 2) (tools/build-examples/src/bin/update-wasm-opt.rs)
• Duplicated block (11 lines × 2) (packages/yew-agent-macro/src/oneshot.rs)
• Duplicated block (11 lines × 2) (packages/yew-agent/src/oneshot/provider.rs)
• Duplicated block (11 lines × 2) (packages/yew-macro/src/hook/body.rs)
• Duplicated block (11–19 lines × 2) (packages/yew-macro/src/html_tree/html_loop.rs)
• Duplicated block (12 lines × 2) (packages/yew-agent-macro/src/agent_fn.rs)
• Duplicated block (12 lines × 2) (packages/yew-agent-macro/src/agent_fn.rs)
• Duplicated block (12 lines × 2) (packages/yew/src/virtual_dom/mod.rs)
• Duplicated block (14 lines × 2) (packages/yew/src/functional/hooks/use_prepared_state/feat_ssr.rs)
• Duplicated block (17 lines × 2) (packages/yew-macro/src/html_tree/html_match.rs)
• Duplicated block (18–19 lines × 2) (tools/changelog/src/stdout_tag_description_changelog.rs)
• Duplicated block (19 lines × 2) (packages/yew-macro/src/props/prop.rs)
• Duplicated block (19 lines × 2) (packages/yew/src/functional/hooks/use_prepared_state/feat_hydration_ssr.rs)
• Duplicated block (19 lines × 2) (packages/yew/src/functional/hooks/use_transitive_state/feat_hydration_ssr.rs)
• …and 282 more

• 2 commits — 1 feature/other, 1 fixes

• .github/workflows — 1 commit
• packages/yew-macro — 1 commit

• fix: chore: fix benchmark action (#4207)
• change: chore: Stop rust-analyzer from marking all #[hook] macros as inactive_code (#4206)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

yewstack/yew was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.