infernojs/inferno

This system is the Inferno UI library, a high-performance JavaScript framework for building user interfaces using a virtual DOM. It provides core rendering capabilities alongside specialized packages for routing, state management integration (Redux, MobX), server-side rendering, and CSS-based animations. The codebase also includes a compatibility layer for React APIs and a suite of testing utilities to facilitate component development and verification.

46 changes.

The project was restructured into a pnpm monorepo with modernized TypeScript and SWC tooling, while significantly expanding its ecosystem through the introduction of dedicated packages for server-side rendering, routing, Redux, and MobX integration. This period also focused on enhancing React compatibility, refining core rendering and event handling logic, and establishing comprehensive test coverage across the new modular architecture.

22 changes.

This period focused on restructuring the codebase by extracting server-side hydration and virtual DOM utilities into dedicated packages, while introducing a new animation system. Significant effort was also directed toward modernizing the build infrastructure and expanding comprehensive test coverage across core rendering, routing, and utility modules.

The inferno-vnode-flags package now includes a README documenting the available VNodeFlags, ChildFlags, and their masks, along with an index.cjs entry point that conditionally loads the production or development build based on the NODE\_ENV variable.

packages/inferno-vnode-flags · high confidence

The inferno-utils package now exports three new functions: createContainerWithHTML, which creates a div element populated with provided HTML; validateNodeTree, which recursively checks if a VNode tree is valid by ensuring elements have DOM references and their children are valid; and triggerEvent, which programmatically dispatches mouse and HTML events on DOM elements for testing purposes.

packages/inferno-utils/src · high confidence

The \packages/inferno-mobx/src/utils\ module now includes an \EventEmitter\ class to manage listener registration and emission, along with an \isStateless\ utility function to detect stateless components by checking for the absence of a render method on the prototype.

packages/inferno-mobx/src/utils · high confidence

Introduces server-side rendering capabilities for Inferno, providing \renderToString\ for synchronous HTML generation and streaming APIs (\RenderStream\, \RenderQueueStream\) for \streamAsString\ and \streamQueueAsString\. The implementation supports class and functional components, fragments, context passing, and controlled form elements (inputs, selects, textareas), while including security measures such as tag name validation, attribute name sanitization, and text escaping to prevent XSS vulnerabilities.

packages/inferno-server/src · high confidence

The new \inferno-compat\ package provides a compatibility layer that allows React-based modules to work with Inferno without code changes by aliasing \react\ and \react-dom\. It exposes equivalents for core React APIs (such as \createElement\, \Component\, \PureComponent\, and \Children\ helpers) and \react-dom\ methods (including \render\, \hydrate\, and \findDOMNode\), while handling specific React behaviors like camelCase style conversion and event normalization. This enables users to integrate existing React libraries into their Inferno projects using standard bundler aliases.

packages/inferno-compat · high confidence

This entry introduces the \inferno-mobx\ package, providing bindings between MobX and Inferno. It exports \observer\ and \inject\ decorators, a \Provider\, and development utilities. New capabilities include \observerPatch\ for turning class components into MobX observers and \observerWrap\ for functional components, allowing them to react to observable changes without wrapping them in class components. The package is compatible with Inferno v1+ and requires the \mobx\ dependency.

packages/inferno-mobx · high confidence

The inferno-router package is now available, providing a routing library for Inferno applications. It is a port of react-router (originally v4, later updated to v5) and includes features such as NavLink function support for className and style attributes, as well as async data fetching via the loader attribute. The package supports both client-side rendering with BrowserRouter and server-side rendering with StaticRouter, and is distributed via CommonJS entry points.

packages/inferno-redux, packages/inferno-router · high confidence

This change introduces the \inferno-test-utils\ package, providing a suite of utilities for testing Inferno applications. The package exposes functions for querying rendered VNode trees and DOM elements, such as \findAllInRenderedTree\, \scryRenderedDOMElementsWithClass\, and \findRenderedDOMElementWithTag\, along with helpers to inspect VNode types (e.g., \isVNode\, \isClassVNode\). It also includes \renderIntoContainer\ to render vNode trees into a detached DOM element, addressing previous memory leak issues associated with the removed \renderIntoContainer\ method in older contexts. The package is distributed via CommonJS entry points (\index.cjs\) that conditionally load minified or development builds based on the \NODE\_ENV\.

packages/inferno-test-utils · high confidence

A new \inferno-shared\ package has been added to centralize common utility functions used across the Inferno library. This includes type-checking helpers such as \isArray\, \isStringOrNumber\, \isNullOrUndef\, \isInvalid\, \isFunction\, \isString\, \isNumber\, \isNull\, and \isUndefined\, as well as error handling utilities like \throwError\ and \warning\. The package also provides \hoistStaticProperties\ to manage static property inheritance between components and \isValidElement\ to verify VNode validity, ensuring consistent behavior and reducing code duplication in dependent packages.

packages/inferno-shared/src · high confidence

Adds the \inferno-test-utils\ package, providing utilities for testing Inferno components. This includes type-checking helpers (e.g., \isVNodeOfType\, \isDOMElementOfType\), tree traversal functions (\findAllInRenderedTree\, \findAllInVNodeTree\), and DOM element finders (\scryRenderedDOMElementsWithClass\). It also introduces Jest-specific snapshot utilities (\renderToSnapshot\, \vNodeToSnapshot\) that allow developers to generate and compare snapshot representations of rendered components, including handling of \className\ and removal of \children\ props for cleaner snapshots.

packages/inferno-test-utils/src · high confidence

The inferno-hyperscript package now provides an h() function that allows creating virtual nodes using a syntax similar to other hyperscript libraries. A key feature is the ability to pass CSS selectors (e.g., 'div\#id.class') as the tag argument, which automatically extracts the id and class names into the resulting node's props, simplifying the creation of DOM elements with common attributes.

packages/inferno-hyperscript/src · high confidence

The \packages/inferno-create-element/src\ package now provides the core \createElement\ function, which constructs Virtual DOM nodes (VNodes) for both DOM elements and components. This implementation handles the extraction of special props such as \key\, \ref\, and \className\ (aliasing \class\), manages child normalization for single or multiple children, and supports Inferno-specific lifecycle hooks (e.g., \onComponentDidMount\) by attaching them to the component's ref object. It also introduces support for Fragments and content-editable elements via specific VNode flags.

packages/inferno-create-element/src · high confidence

The \scripts/fakedom\ directory now includes a complete build and execution environment for running UI benchmarks. A new Rollup-based build script (\build.js\) compiles benchmark applications into optimized ESM bundles, utilizing plugins for CommonJS resolution, Babel transformation (including the Inferno plugin), and minification. A JSDOM-based setup file (\libs/setup.js\) provides the necessary browser globals (window, document, requestAnimationFrame) to run these benchmarks in a Node.js environment. The directory also contains the core benchmark logic (\libs/uibench.js\) defining state models for tables, animations, and trees, along with baseline performance results (\results/inferno\_base\_line.json\) to track memory and CPU usage over time.

scripts/fakedom · high confidence

A new \inferno-animation\ package has been added to provide helper components and utilities for adding smooth CSS animations to Inferno applications. Users can extend from \AnimatedComponent\, \AnimatedMoveComponent\, or \AnimatedAllComponent\ to easily animate elements on add, remove, or move events within keyed lists. The package includes a default CSS stylesheet (\index.css\) that handles opacity and height transitions, and supports custom animation names via props. It also exposes lifecycle hooks (\componentDidAppear\, \componentWillDisappear\, \componentWillMove\) for functional components and implements a move engine that coordinates transforms for reordering, insertions, and removals during reconciliation.

packages/inferno-animation · high confidence

A new package, inferno-clone-vnode, has been introduced to provide functionality for cloning Inferno virtual nodes. This package exposes a cloneVNode function that creates a new vNode based on an existing one, allowing for shallow merging of props and replacement of children while preserving the original key and ref. It is designed to be compatible with React's cloneElement API, offering an alternative for users familiar with React patterns. The package includes CommonJS entry points that conditionally load minified or development builds based on the environment.

packages/inferno-clone-vnode · high confidence

A new package named inferno-create-element has been added to provide helpers for creating Inferno elements. Users can now install this package separately and use its createElement function to construct elements, which can then be rendered using the main inferno library.

packages/inferno-create-element · high confidence

A new package, inferno-extras, has been added to provide pure functions for working with the InfernoJS virtual DOM. It includes the isDOMInsideComponent and isDOMInsideVNode methods, which help determine if a DOM node exists within the children of a component instance or virtual node, respectively. This is particularly useful for handling event propagation in scenarios where native DOM methods like node.contains may fail, such as with Portals.

packages/inferno-extras · high confidence

A new \inferno-hydrate\ package has been introduced to handle hydration of HTML content previously rendered by \Inferno-server\. This package provides a \hydrate\ function that attaches event listeners to existing markup, mirroring the behavior of \render()\ but optimized for pre-rendered content. The package includes CommonJS entry points that conditionally load minified or development builds based on the \NODE\_ENV\.

packages/inferno-hydrate · high confidence

A new \inferno-server\ package has been added to provide server-side rendering capabilities, including \renderToString\, \renderToStaticMarkup\, and various streaming utilities. The package exposes CommonJS (\index.cjs\) and ES Module (\index.mjs\) entry points, with the CJS version conditionally loading production or development builds based on \NODE\_ENV\. The ES module entry point includes a warning mechanism to alert users if the production build is used in a development environment within a browser context.

packages/inferno-server · high confidence

The inferno-router-demo has been rewritten to demonstrate server-side rendering (SSR) and async data prefetching. The demo now uses a Koa server to render pages on the server, passing initial data to the client for hydration. Pages like AboutPage and ContentPage define static fetchData methods to prefetch data, which are resolved on the server using inferno-router's loader utilities before rendering. The demo includes a basic API endpoint structure and uses Parcel for bundling both server and client bundles.

demo/inferno-router-demo · high confidence

The inferno-extras package now exports three new utility functions: findDOMNode, isDOMInsideVNode, and isDOMInsideComponent. findDOMNode resolves a DOM node from a VNode, Component, or existing Node reference, returning null if the reference is invalid or unmounted. isDOMInsideVNode checks whether a specific DOM element is contained within the subtree of a given VNode, while isDOMInsideComponent performs the same check for a Component instance. These utilities provide developers with reliable ways to inspect the relationship between DOM elements and Inferno's virtual DOM structure.

packages/inferno-extras/src · high confidence

The inferno-mobx package now includes a port of key mobx-react features: the Provider component for injecting MobX stores into the context tree, observerPatch for converting class components into observers, and observerWrap for wrapping functional components. These additions complete the library's compatibility with the mobx-react API, allowing developers to use standard MobX reactive patterns with Inferno components.

packages/inferno-mobx/src · high confidence

The \Engine.js\ and \EngineDocument.js\ files have been deleted from the EngineJS directory. This removes the previous implementation of the document creation API (\Engine.createDocument\) and the \EngineDocument\ class, which previously handled virtual DOM mounting and rendering loops via \requestAnimationFrame\.

EngineJS · high confidence

The empty ListNavigation component has been removed from the codebase, eliminating unused code that provided no functionality to the user.

components · high confidence

The hydration functionality has been moved from the core Inferno package into a new, standalone \inferno-hydrate\ package. This change decouples server-side rendering hydration from the main runtime, allowing users to import hydration-specific code separately if needed, while the core library remains focused on client-side rendering.

packages/inferno-hydrate/src · high confidence

The DOM rendering logic in the Inferno core library has been reorganized into distinct, dedicated modules for mounting, patching, unmounting, and property handling. This structural change separates the concerns of creating new DOM nodes, updating existing ones, and cleaning them up, while introducing a new constants file to centralize XML/XLink namespace definitions. For users, this represents an internal architectural improvement that maintains existing rendering behavior and API compatibility while improving code maintainability and potentially aiding runtime performance through better code splitting and V8 optimization.

packages/inferno/src/DOM · high confidence

The project has been migrated from a legacy single-package structure to a pnpm workspace monorepo, organizing source code into individual packages (e.g., inferno, inferno-compat, inferno-router) under a \packages/\ directory. This change introduces a new build and test infrastructure using TypeScript (targeting ES2022), SWC for compilation, and Jest for testing, replacing previous tooling. Legacy artifacts such as the \bundle.js\ entry point and \npm-debug.log\ have been removed, and configuration files like \.editorconfig\, \.gitattributes\, and \eslint.config.js\ have been added to standardize code formatting and linting across the new workspace.

(repo-wide) · high confidence

The \h()\ function in inferno-hyperscript now accepts an optional \noNormalize\ boolean parameter. When set to true, it skips the normalization process, allowing Inferno to trust the input as-is for optimization purposes.

packages/inferno-hyperscript · high confidence

The browser test infrastructure has been rebuilt to use Jasmine as the test runner and Webpack 5 for bundling, replacing the previous Karma-based setup. This change introduces a new build pipeline that supports multiple JSX transformation variants (Babel, TypeScript, and SWC) and allows tests to be run with and without the \inferno-compat\ layer, as well as in minified mode. The new fixtures include a local runner for validating these combinations in Firefox and Chromium, and a dedicated script for executing tests across multiple browser versions on Sauce Labs.

fixtures · high confidence

The Rollup build script has been rewritten to use the native ES Module (ESM) system, replacing the previous CommonJS implementation. This change updates the build tooling to use ESM syntax (e.g., \import\/\export\, \import.meta.url\) and aligns with the project's broader shift to \type: module\ in package manifests, ensuring consistent module handling across the build pipeline.

scripts/rollup · high confidence

The core component implementation has been restructured to improve performance and reliability. State updates are now batched using a microtask queue, ensuring that multiple setState calls are processed together and callbacks are invoked in the correct order. The Component class is now an abstract base class, and the library introduces a new createRef API alongside support for forwardRef, allowing functional components to receive and forward DOM references. Additionally, the core now includes native event type definitions for Clipboard, Composition, Drag, and Focus events to improve TypeScript compatibility.

packages/inferno/src/core · high confidence

The inferno-compat package now includes additional modules to improve compatibility with React APIs. This update adds support for ReactFragment, ReactMount, ReactTransitionEvents, and ReactTransitionGroup, allowing code relying on these specific React utilities to function within Inferno. Additionally, the package has switched its CSS transition group implementation from rc-css-transition-group to rc-css-transition-group-modern to address compatibility issues, and introduces new event handling utilities (EventConstants, EventPluginHub, EventPluginUtils, EventPropagators, SyntheticUIEvent, ViewportMetrics) along with a shallowCompare helper to better mimic React's internal event and rendering behaviors.

packages/inferno-compat/lib · high confidence

The cloneVNode function has been moved into its own package (inferno-clone-vnode) and rewritten to explicitly handle child arguments, allowing users to override the cloned node's children via props or additional arguments. This change improves backwards compatibility and enables tree-shaking by modern bundlers, while ensuring that the original props object is not mutated during the cloning process.

packages/inferno-clone-vnode/src · high confidence

The inferno-compat package now maps SVG attributes to their correct hyphen-case names (e.g., \fontVariant\ to \font-variant\) and converts camelCase inline styles to hyphen-case (e.g., \backgroundColor\ to \background-color\). This ensures that SVG elements render correctly and that inline CSS styles, including those with numeric values, behave consistently with React's expectations.

packages/inferno-compat/src · high confidence

The main entry point for the Inferno package now explicitly exports a comprehensive set of public APIs, including core rendering functions (render, rerender, createRenderer), VNode creation utilities (createVNode, createFragment, createTextVNode, createPortal), component utilities (Component, createRef, forwardRef), and DOM helpers (linkEvent, normalizeProps). It also exposes internal methods prefixed with underscores (e.g., \_CRH, \_CI, \_M) specifically for use by companion packages like inferno-animation and inferno-mobx. Additionally, a development-mode warning is now included to alert users if they are accidentally using the development build in production.

packages/inferno/src · high confidence

The Provider and connectAdvanced components in inferno-redux have been rewritten in TypeScript, introducing strict type definitions for Redux store integration and component props. This change improves type safety for developers using Inferno with Redux, ensuring better compile-time checks for store context and connected component behavior, while maintaining the existing runtime functionality for state management and component wrapping.

packages/inferno-redux/src/components · high confidence

The inferno-router package has been completely rewritten in TypeScript, introducing a new data-loading architecture where routes can define async loaders that fetch data before rendering. This change brings the router closer to the React Router v6 API, adding support for loaders, initial data, and static context. The package now includes dedicated router components for different environments: BrowserRouter, HashRouter, MemoryRouter, and StaticRouter. Core components like Link, NavLink, Route, Switch, Redirect, and Prompt have been updated to support the new loader system and improved type safety. The NavLink component now supports a function-based className prop for dynamic styling based on active state. The router also introduces helper hooks useLoaderData and useLoaderError for accessing loader results within components.

packages/inferno-router/src · high confidence

The \inferno-redux\ package now includes its own implementations of core utility functions previously likely sourced from external dependencies or other packages. Specifically, \Subscription.ts\ provides a listener collection and subscription management class to handle state changes and nested subscriptions, \shallowEqual.ts\ implements a shallow equality check for comparing props or state, \verifyPlainObject.ts\ adds validation to ensure plain objects are returned where expected, \warning.ts\ centralizes console error logging for development warnings, and \wrapActionCreators.ts\ wraps action creators using Redux's \bindActionCreators\. These changes consolidate internal logic within the \utils\ directory to support the Redux binding layer.

packages/inferno-redux/src/utils · high confidence

The \inferno-vnode-flags\ package now exports explicit \VNodeFlags\ and \ChildFlags\ enums to define the shape and children of virtual nodes. \VNodeFlags\ categorizes nodes into types such as HTML, SVG, components (class, function, unknown), text, portals, fragments, and content-editable elements, along with state flags like \InUse\ and \Normalized\. \ChildFlags\ defines how children are structured, distinguishing between invalid, single vNode, keyed, non-keyed, and text children. These bitwise flags are used to optimize vNode size and diffing performance by allowing the runtime to quickly identify node types and child structures without complex object checks.

packages/inferno-vnode-flags/src · high confidence

The build process now includes new utility scripts to improve developer experience and output management. A new \bundle-size.js\ script automatically generates a table displaying file sizes (including gzip) for all Inferno packages, helping users monitor bundle impact. Additionally, \move-compiled.js\ and \move-typedefs.js\ handle the post-build copying of source files and TypeScript type definitions to the distribution directories, ensuring that consumers receive the necessary type information alongside the compiled code.

scripts/bundle · high confidence

The \packages/inferno\ and \packages/inferno-shared\ packages now include \index.cjs\ stubs that conditionally load the minified production build or the development build based on \NODE\_ENV\. Additionally, the \index.mjs\ entry point for native ES modules now includes a runtime warning that alerts users if they are using the production bundle in a development environment, helping to catch configuration mistakes in browser-based native ES module usage.

packages/inferno · high confidence

The DOM utility layer has been reorganized into dedicated modules (common, componentUtil, innerHTML) to improve maintainability and performance. A key behavioral addition is the integration of move animations: the system now supports data-driven move animations for class components (via componentWillMove) and function components (via hooks), allowing elements to animate their position changes during reconciliation. Additionally, legacy lifecycle methods (componentWillMount, componentWillReceiveProps, componentWillUpdate) are now deprecated with warnings when using new component APIs, and the Fragment implementation has been refined to correctly handle container changes and child rendering.

packages/inferno/src/DOM/utils · high confidence

The \connect\ implementation in \inferno-redux\ has been restructured from a monolithic component into a modular system of factory functions. The new \connect.ts\ entry point delegates to specialized modules for \mapStateToProps\, \mapDispatchToProps\, \mergeProps\, and \selectorFactory\. This change introduces explicit handling for the \dependsOnOwnProps\ flag in the selector factories, ensuring that components correctly re-evaluate when their own props change, and adds development-time warnings for selectors that omit this flag. Users benefit from more predictable prop-update behavior and clearer error messages during development.

packages/inferno-redux/src/connect · high confidence

The event handling logic in the DOM layer has been restructured into three distinct modules: \attachEvent.ts\ for direct DOM listener attachment, \delegation.ts\ for implementing event delegation on the document level (including support for shadow DOM via \composedPath\ and proper handling of disabled elements), and \linkEvent.ts\ for linking data to event callbacks. This change replaces previous inline or monolithic event logic with a cleaner, modular approach that improves performance and cross-browser compatibility, specifically addressing issues with event propagation and synthetic event properties like \currentTarget\.

packages/inferno/src/DOM/events · high confidence

The DOM wrapper logic for form elements has been restructured into dedicated modules (InputWrapper, SelectWrapper, TextareaWrapper) and a central processElement handler. This change introduces specific event attachment strategies—such as using 'input' for text fields and 'change' for checkboxes/radios—and implements controlled value synchronization that correctly handles defaultValue, value, and checked props. Users benefit from more reliable form state management, particularly for controlled inputs and selects, and reduced risk of stale event handlers when elements are unmounted.

packages/inferno/src/DOM/wrappers · high confidence

The \inferno-animation\ package has been completely rewritten to provide a more robust and coordinated animation engine. Users can now extend the new abstract base classes—\AnimatedComponent\, \AnimatedAllComponent\, and \AnimatedMoveComponent\—to integrate animations into their components. The lifecycle methods have been renamed to \componentDidAppear\, \componentWillDisappear\, and \componentWillMove\ to align with standard naming conventions and prevent conflicts. The new system introduces a global animation coordinator that batches and phases animations (measure, initialize, activate) to reduce reflows and improve performance. It also supports data-driven move animations for keyed lists, allowing elements to animate their position changes smoothly. Additionally, the package now exports utility functions for common DOM operations like class management and dimension retrieval.

packages/inferno-animation/src · high confidence

The inferno-redux package now exports all public APIs (Provider, connect, connectAdvanced, wrapActionCreators, shallowEqual, and related types) as named exports rather than a single default export. This change allows consumers to import specific functions directly (e.g., import { connect } from 'inferno-redux') instead of relying on a default import, aligning with modern module standards and improving tree-shaking compatibility.

packages/inferno-redux/src · high confidence

The browser distribution now includes the \babel-plugin-inferno\ version 6.6.0, which updates the underlying Babel transformation logic for JSX and TypeScript support in the compiled output.

browser · high confidence

The build system now uses the modern @rollup/plugin-alias and @rollup/plugin-terser packages instead of their deprecated predecessors. This change ensures that UMD bundles correctly handle Node.js-specific modules like 'stream' by providing a stub, preventing runtime errors when loading the server bundle in browsers.

scripts/rollup/plugins · high confidence

The inferno-router-demo has been updated to require Node.js \>=24 and Babel 8, replacing the previous build setup with a custom Parcel transformer to handle the new JSX plugin requirements. This change includes a new backend test suite to verify server startup, API endpoints, and frontend route serving, alongside updated configuration files for TypeScript, Parcel, and Babel to ensure the demo runs correctly with the latest dependencies.

demo · high confidence

A new \streamUtils.ts\ file has been added to the \inferno-server\ package, introducing a \mergePendingState\ function. This utility handles the merging of pending component state (\$PS\) into the current state during server-side rendering, ensuring that state updates are correctly applied before rendering proceeds.

packages/inferno-server/src/stream · high confidence

Added React compatibility tests for inferno-compat; Added TypeScript tests for hyperscript rendering behavior; Added comprehensive test suite for cloneVNode; Added comprehensive test suite for inferno-animation; Added comprehensive test suite for inferno-mobx integration; Added comprehensive test suite for inferno-router components; Added test coverage for inferno-utils; Added test infrastructure scripts for Jest and Jasmine environments; Added tests for EventEmitter listener management; Added tests for functional component lifecycle hooks in inferno-redux; Added tests for inferno-redux Provider and connect components; Added tests for inferno-test-utils; Added tests for isDOMInsideComponent and isDOMInsideVNode utilities; Added unit tests for shallowEqual and wrapActionCreators utilities; Expanded test coverage for Inferno core rendering and lifecycle behaviors; Expanded test coverage for Inferno server-side rendering.

This release updates the Inferno core and all related packages (inferno-compat, inferno-router, inferno-mobx, inferno-redux, inferno-server, inferno-hydrate, inferno-hyperscript, inferno-create-element, inferno-animation, inferno-clone-vnode, inferno-extras, inferno-shared, inferno-vnode-flags, inferno-test-utils) to version 9.1.0. Additionally, a new browser fixture test suite has been added to validate the library across different JSX transformers (Babel, TypeScript, SWC) using Jasmine, Webpack, and Sauce Labs.

(dependencies) · high confidence

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

• CAI 62 → 65 (+3.1)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 73 → 70 (-2.6)
• Architecture 67 → 73 (+6.0)
• Maturity 59 → 55 (-3.7)
• Readiness 78 → 85 (+7.0)
• Security 60 → 82 (+21.2)
• Performance 85 (new)

• Documentation: contradicts the code (docs/index.html)
• Documentation: no installation or build instructions (README.md)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 46 more

• Documentation: no architecture or design documentation (docs/index.html)
• Documentation: no project overview (docs/index.html)
• FileTooLong: animation-glitch/app.js (docs/animation-glitch/app.js)
• FileTooLong: src/animations.ts (packages/inferno-animation/src/animations.ts)
• FileTooLong: uibench/custom-uibench.js (docs/uibench/custom-uibench.js)
• FunctionTooLong: animations.runMove (packages/inferno-animation/src/animations.ts)
• FunctionTooLong: custom-uibench.initTests (docs/uibench/custom-uibench.js)
• FunctionTooLong: patching.patchElement (packages/inferno/src/DOM/patching.ts)
• FunctionTooLong: props.patchProp (packages/inferno/src/DOM/props.ts)
• FunctionTooLong: renderToString.renderVNodeToString (packages/inferno-server/src/renderToString.ts)
• High: security finding (details withheld)
• Hotspot: packages/inferno-create-element/src/index.ts (packages/inferno-create-element/src/index.ts)
• Hotspot: packages/inferno-server/src/renderToString.queuestream.ts (packages/inferno-server/src/renderToString.queuestream.ts)
• Hotspot: packages/inferno-server/src/renderToString.stream.ts (packages/inferno-server/src/renderToString.stream.ts)
• Hotspot: packages/inferno-server/src/renderToString.ts (packages/inferno-server/src/renderToString.ts)
• Hotspot: packages/inferno/src/DOM/mounting.ts (packages/inferno/src/DOM/mounting.ts)
• Hotspot: packages/inferno/src/DOM/patching.ts (packages/inferno/src/DOM/patching.ts)
• Hotspot: packages/inferno/src/DOM/props.ts (packages/inferno/src/DOM/props.ts)
• Hotspot: packages/inferno/src/DOM/unmounting.ts (packages/inferno/src/DOM/unmounting.ts)
• Hotspot: packages/inferno/src/core/implementation.ts (packages/inferno/src/core/implementation.ts)
• …and 43 more

• 73 commits — 11 feature/other, 62 fixes

• packages/inferno — 25 commits
• packages/inferno-server — 17 commits
• packages/inferno-router — 5 commits
• (root) — 3 commits
• packages/inferno-compat — 3 commits
• packages/inferno-hydrate — 3 commits
• packages/inferno-mobx — 3 commits
• packages/inferno-animation — 2 commits
• packages/inferno-create-element — 2 commits
• scripts/rollup — 2 commits
• .github/workflows — 1 commit
• demo/inferno-router-demo — 1 commit
• docs/animation-glitch — 1 commit
• docs/autofocus_bug — 1 commit
• packages/inferno-clone-vnode — 1 commit
• packages/inferno-hyperscript — 1 commit
• packages/inferno-redux — 1 commit
• scripts/babel — 1 commit

• fix: Fix an issue where hydration uses a vNode that is already mounted in another position of the same tree or in another container, it uses the same vNode object for the server rendered DOM node. After the next render one of the positions is not updated.
• fix: fix an issue where CI never runs the tests that need a DOM-free environment
• fix: fix an issue where Prompt stops blocking after the first confirmed transition
• fix: fix an issue where Redirect drops the state of a location object
• fix: fix an issue where Redirect in a Switch goes to its to path without the params
• fix: fix an issue where RenderQueueStream never ends as a readable stream
• fix: fix an issue where Switch crashes on false, null and undefined children
• fix: fix an issue where Switch drops the key of the matched Route
• fix: fix an issue where TypeScript finds the types of every package only through a fallback
• fix: fix an issue where a Fragment created with an empty children array and explicit child flags renders nothing on the server, while in the browser it renders an empty text node. Server rendered HTML then does not match the browser. When the server renders the placeholder that other empty Fragments get, hydration keeps the Fragment with the empty array and the next render throws "Cannot read properties of null (reading 'nextSibling')".
• fix: fix an issue where a Fragment with exactly one child is removed, the child is not unmounted. Class components inside it never get componentWillUnmount, refs are not cleared, and the content of a Portal inside it stays in the portal container.
• fix: fix an issue where a Portal is re-rendered with a different container and its child is a component or a Fragment, rendering throws "Failed to execute 'removeChild' on 'Node': parameter 1 is not of type 'Node'". The content is not moved to the new container.
• fix: fix an issue where a component is unmounted and mounted again, losing its state, when the element rendered in its place is equal but was normalized as the child of some other element earlier.
• fix: fix an issue where a hoisted vNode with multiple children renders the children of some other vNode after an element of the same type has been patched in its place. This is trade-off between performance and correctness. Modern browsers handle try catch - performance really well. Optimize later.
• fix: fix an issue where a ref passed through spread props to a forwardRef component is lost
• fix: fix an issue where a vNode referenced outside of render and placed in two positions shares its DOM node and state between them. After the next render one of the positions is not updated, or rendering throws NotFoundError.
• fix: fix an issue where a vNode referenced outside of render is cloned every time it is rendered again, even when it is rendered in the same position as before. Hoisted vNodes, the root passed to render() again and the root returned by a component allocate a new vNode on every render.
• fix: fix an issue where an element vNode with multiple children that is rendered in two places is updated only in one of them afterwards.
• fix: fix an issue where an option without a value prop gets the value "undefined"
• fix: fix an issue where cloneVNode writes children into the props passed to it
• …and 53 more

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

infernojs/inferno 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.