Skip to content
CAI
Software that uses CAICheck a score

plotly/dash

41.1

Weak · 16 November 2026

67.6k

lines of production code

TypeScript

with Python, JavaScript

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add TypeScript component generation support with type hints

The base module for the test component now supports TypeScript generation. This includes a new \_\init\\_.py that loads version and package metadata from package.json, imports generated components, and configures JavaScript distribution paths (including a dev-only proptypes.js file). Additionally, a py.typed marker file has been added to enable static type checking for this package.

@plotly/dash-generator-test-component-typescript/base · high confidence

Add TypeScript component type definitions for testing

This change introduces the initial TypeScript source files for the \@plotly/dash-generator-test-component-typescript\ package. It defines the \TypescriptComponentProps\ interface in \props.ts\, specifying a comprehensive set of prop types including primitives, enums, unions, tuples, objects, and React elements, along with specific component exports in \index.ts\. This establishes the type contract for the test components used to validate TypeScript generation in the Dash generator.

@plotly/dash-generator-test-component-typescript/src · high confidence

Add development tooling and configuration files

The repository now includes standard development configuration files to improve code quality and developer experience. This adds \.editorconfig\ for consistent editor settings, \.flake8\ and \.pylintrc\ for Python linting, \.lintstagedrc.js\ for pre-commit linting, \.npmrc\ and \.nvmrc\ for Node.js configuration, and \.gitignore\ to exclude build artifacts and environment files. It also adds \.envrc\ for automatic virtual environment activation via direnv, \AGENTS.md\ for AI assistant guidance, and \.test\_durations\ for tracking test performance.

(repo-wide) · high confidence

Added R documentation vignettes for Dash Core and HTML components

New R Markdown vignettes and their compiled HTML outputs have been added for the \dashCoreComponents\ and \dashHtmlComponents\ packages. These documents provide interactive examples and usage guides for R users, covering key UI elements such as Dropdowns, Sliders, and standard HTML wrappers.

(repo-wide) · high confidence

Added async component test utilities

The test components library now includes an AsyncComponent and an AsyncComponentLoader to support testing scenarios involving dynamic component loading. The AsyncComponent is a simple React component that renders a div with an id and value, while the AsyncComponentLoader uses dynamic imports to load the AsyncComponent, enabling tests for asynchronous rendering behaviors.

@plotly/dash-test-components/src/fragments · high confidence

Added test components for nested artifacts and arbitrary file extensions

Two new test components, \@plotly/dash-generator-test-component-nested\ and \@plotly/dash-generator-test-component-standard\, have been added to validate component suite generation. The nested component demonstrates support for assets located in subdirectories (e.g., \nested/\), while the standard component includes a CSS file and a custom font (\godfather.ttf\) to verify that arbitrary file extensions and dynamic assets are correctly bundled and served.

@plotly/dash-generator-test-component-standard · high confidence

Dash Table component rewrite and export functionality

The Dash Table component has been rewritten in TypeScript, introducing a new modular architecture with dedicated factories for cells, filters, headers, and edges, alongside a new LazyLoader for on-demand imports of xlsx and highlight.js. This update adds a new Export feature allowing users to download table data as CSV or XLSX files, and improves user interaction by fixing active cell selection during shift-click area selection, enabling text copying for non-selectable cells, and allowing special characters in column IDs.

components/dash-table/src/dash-table · high confidence

Expanded test component library for Dash callback and persistence scenarios

The @plotly/dash-test-components package has been significantly expanded with new components designed to validate complex Dash behaviors. Key additions include ComponentAsProp, which supports passing React elements, shapes, and nested lists/objects as props to test dynamic callback handling, and ExternalWrapper usage in ExternalComponent for testing external component integration. MountStateComponent addresses state initialization timing issues (fixing \#3929) by ensuring initial state set on mount is preserved. Persistence testing is enhanced with MyPersistedComponent and MyPersistedComponentNested, supporting both simple and nested value persistence with custom transforms. Additional components like AddPropsComponent, ReceivePropsComponent, and RenderType (with dashRenderType support) facilitate testing of prop passing, rendering types, and callback graph integrity.

@plotly/dash-test-components/src/components · high confidence

Initial JupyterLab extension for embedding Dash apps

This change introduces the initial implementation of the JupyterLab extension for Dash, adding the core source files, TypeScript configuration, and styling required to embed Dash applications within the JupyterLab interface. The extension registers a kernel communication target to receive 'show' and 'base\_url\_request' messages from Dash backends, dynamically creating and managing iframe widgets in the main work area for both notebook and console sessions.

@plotly/dash-jupyterlab · high confidence

Initial release of @plotly/dash-component-plugins

This entry introduces the new @plotly/dash-component-plugins package, providing core utilities for Dash component development. It includes a History module for managing location change events via custom DOM events, and dynamic import utilities (asyncDecorator, inheritAsyncDecorator, isReady) that enable async support and lazy loading of React components while exposing readiness state to the Dash runtime. The package is built with Webpack 5 and Babel, targeting UMD output for broad compatibility.

@plotly/dash-component-plugins · high confidence

Initial release of @plotly/dash-test-components package

The @plotly/dash-test-components package is now available, providing a set of test components for Dash applications. This release includes the necessary build configuration (Webpack, Babel) and Python setup files to package and distribute these components, enabling developers to use them for testing purposes within their Dash apps.

@plotly/dash-test-components · high confidence

Introduce SharedWorker for WebSocket-based Dash callbacks

Adds a new \@plotly/dash-websocket-worker\ package that implements a SharedWorker to maintain a single WebSocket connection shared across multiple browser tabs (renderers). This worker handles callback request routing, batches \set\_props\ updates for efficiency, and manages connection lifecycle features including automatic reconnection with configurable retry delays, heartbeat keep-alives, and inactivity-based disconnection. Users benefit from reduced network overhead and improved stability when interacting with Dash apps across multiple tabs.

@plotly/dash-websocket-worker · high confidence

Introduce dedicated Format and FormatTemplate modules for table cell styling

The \dash\_table\_base\ package now exposes \Format\ and \FormatTemplate\ as first-class components, allowing users to define precise cell formatting rules. The \Format\ class provides a fluent API for configuring alignment, grouping, padding, precision, numeric schemes (such as decimal, exponent, or hexadecimal), signs, symbols, and trimming. The \FormatTemplate\ module offers convenient factory functions, including \money\ for currency formatting with grouping and symbols, and \percentage\ for decimal or rounded percentage displays. These modules are automatically included in the package's public API.

_components/dash-table/dash\_table\base · high confidence

Introduce standalone performance benchmark harness for Dash renderer

A new standalone benchmark suite has been added to measure renderer performance for hot paths such as initial hydration, callbacks, wildcards, and patching. This harness runs scenarios via a Python runner that serves production renderer bundles in isolated processes and drives headless Chrome to collect in-browser timing metrics. It includes a committed baseline file for regression gating, threshold-based pass/fail criteria, and support for CPU profiling, allowing developers to track performance trends without the noise of the standard test suite.

benchmarks · high confidence

New and refactored core UI components

This release introduces several new components and significantly refactors existing ones. New additions include dcc.Button for styled clickable elements, dcc.Checklist for multi-select checkboxes, dcc.ConfirmDialog and dcc.ConfirmDialogProvider for native browser confirmation modals, dcc.Download for triggering file downloads, dcc.Geolocation for accessing device location data, dcc.Link for client-side navigation with optional scroll-to-top behavior, dcc.Upload for file uploads (including folder support), dcc.Input for text/number entry, dcc.Interval for periodic callbacks, dcc.Location for tracking URL state, dcc.DatePickerSingle and dcc.DatePickerRange for date selection, and dcc.Loading for overlay spinners. Existing components like dcc.Dropdown, dcc.Graph, and dcc.Input have been rewritten or refactored (many to TypeScript) to improve performance, accessibility, and maintainability, with dcc.Dropdown now supporting virtualized lists for large option sets and dcc.Graph supporting MathJax and clipboard operations.

components/dash-core-components/src/components · high confidence

New debug menu with version notifications and Plotly Cloud integration

A new debug menu component has been added to the bottom-right corner of the application, providing a collapsible interface for developers. It includes a version info section that checks for new Dash releases via a server endpoint, displaying upgrade notifications with options to dismiss, skip, or opt out, while caching results in localStorage. The menu also features a Plotly Cloud placeholder button that opens a modal with installation instructions, and integrates custom devtools via a new DevtoolContext provider. The UI uses Verdana font, supports dark mode styling, and handles errors gracefully when localStorage is unavailable.

dash/dash-renderer/src/components/error/menu · high confidence

New front-end error notification UI

A new front-end error notification system has been introduced, featuring a dedicated error card component that displays error messages, timestamps, and collapsible stack traces. The UI now supports rendering backend errors via an iframe for full HTML documents, while handling HTML fragments and plain text appropriately. The design includes specific styling for error containers, icons for closing and collapsing, and visual indicators for server connectivity status.

dash/dash-renderer/src/components/error/FrontEnd · high confidence

New helper functions for the Download component

The \dash\_core\_components\_base\ package now exposes \send\_bytes\, \send\_string\, \send\_file\, and \send\_data\_frame\ in its public API. These utilities simplify file downloads by allowing users to pass file paths, byte streams, strings, or DataFrame writers (such as \to\_csv\ or \to\_excel\) directly to the Download component, automatically handling the necessary encoding and metadata formatting.

_components/dash-core-components/dash\_core\_components\base · high confidence

New interactive callback dependency graph for debugging

The CallbackGraph component has been introduced to provide an interactive visualization of Dash callback dependencies, helping users debug complex app structures. This new feature renders a directed acyclic graph (DAG) using Cytoscape.js, displaying nodes for components, properties, and callbacks, with edges indicating input, output, and state relationships. Users can now visually inspect callback chains, identify circular dependencies, and see real-time profiling data such as call counts and execution times. The interface includes layout options (top-down, left-right), highlights active/inactive branches upon selection, and visually flags errors or loading states, all styled with the Inter font family and Verdana for text.

dash/dash-renderer/src/components/error/CallbackGraph · high confidence

New interactive demo page for dash-table

A new local development and demonstration environment for the dash-table component has been added. This includes an HTML entry point that loads React 16.14.0 from a CDN, a React application entry point, and a main App component that renders the DataTable with configurable modes (such as filtering, read-only, and markdown support) and mock data sets. The demo allows users to interactively explore table features like native filtering, fixed headers/columns, and editable cells directly in the browser.

components/dash-table/demo · high confidence

New shareable linting and formatting configurations for Dash projects

Added \@plotly/eslint-config-dash\ and \@plotly/prettier-config-dash\ packages to provide standardized code quality settings. The ESLint config extends recommended rules with React and import plugins, enforcing specific style choices like single quotes and no trailing commas. The Prettier config sets a 4-space tab width, single quotes for JSX, and avoids arrow parens, allowing Dash projects to easily adopt these consistent formatting and linting standards.

@plotly/eslint-config-dash, @plotly/prettier-config-dash · high confidence

New streaming and WebSocket utilities for Dash callbacks

The \dash-renderer\ now includes a suite of new utility modules to support advanced callback features. \streamClient.ts\ and \streamWorkerHost.ts\ implement a multiplexed streaming transport that shares a single HTTP downlink across multiple streaming callbacks and browser tabs via a SharedWorker, improving performance and connection management. \workerClient.ts\ provides the client-side interface for WebSocket-based callbacks, handling connection, disconnection, and message routing. \clientsideFunctions.ts\ exposes \set\_props\ and \clean\_url\ to the global \dash\_clientside\ API, allowing clientside callbacks to update component props and sanitize URLs. \propPath.ts\ adds efficient path resolution for partial prop reads, while \rendererId.ts\ generates unique IDs to manage session state. \libraries.ts\ handles dynamic loading of JS and CSS assets, and \wait.ts\ provides a simple promise-based delay utility.

dash/dash-renderer/src/utils · high confidence

New utility modules for Dash Core Components

This change introduces a suite of new utility modules in the components/dash-core-components/src/utils directory to support upcoming component implementations. DatePickerPersistence handles date formatting and parsing using date-fns. LoadingElement provides a wrapper to apply the data-dash-is-loading attribute for CSS-based loading states. ResizeDetector manages window and element resize events using ResizeObserver. computeSliderMarkers, sliderRendering, sliderSnapToMark, and formatSliderTooltip contain the logic for calculating, positioning, and formatting slider marks, dots, and tooltips, including support for reversed sliders and marks outside the selected range. dropdownSearch and optionRendering implement the search indexing, filtering, and virtualized rendering for dropdown options, including support for preserving original option order. optionTypes defines the sanitization logic for dropdown options.

components/dash-core-components/src/utils · high confidence

Security

Introduce background callback security and payload compression

This change adds security hardening for background callbacks by introducing HMAC-signed handles for job and cache keys, preventing replay attacks and unauthorized access to cache entries or process IDs. It also adds support for gzip-compressed callback payloads to reduce network traffic for large requests, with a configurable maximum decompressed size (default 64 MB).

dash · high confidence

Architecture

Dash DataTable project structure and configuration overhaul

The \components/dash-table\ directory has been reorganized with a comprehensive set of new configuration files to standardize development and build processes. This includes adding ESLint and Prettier configurations for consistent code formatting, TypeScript compiler settings (\tsconfig.json\, \tsconfig.base.json\, \tsconfig.lint.json\) for type checking, and Python linting rules (\.flake8\, \.pylintrc\). Build and test infrastructure is established via \babel.config.js\, \karma.conf.js\, \webpack.test.config\, and \pytest.ini\ (configured with \junit\_family=xunit1\ for CI compatibility). Additional files include \.gitignore\, \.npmignore\, \.npmrc\ (with \legacy-peer-deps=true\), \cspell.json\ for spell checking, \renovate.json\ for dependency management, and standard project metadata files like \LICENSE\, \README.md\, \CHANGELOG.md\, \setup.py\, and \dash-info.yaml\ for R package generation.

components/dash-table · high confidence

Behavioural changes

Added F\#, C\#, and MATLAB syntax highlighting support

The Dash Table component now supports syntax highlighting for F\# (fsharp), C\# (csharp), and MATLAB (matlab) in addition to the previously supported languages. This change updates the bundled highlight.js configuration to register these three new language definitions, allowing users to display code blocks in these languages with proper visual formatting within the table cells.

components/dash-table/src/third-party · high confidence

Added undo/redo toolbar and improved hot-reload error handling

The renderer now includes a visual undo/redo toolbar (Toolbar.react.js, Toolbar.css) that appears in the bottom-left corner during development, allowing users to step back and forward through state changes. Additionally, the hot-reload mechanism (Reloader.react.js) has been updated to provide better feedback when reloads fail; specifically, it now displays a persistent alert after a configurable number of retries, helping users identify and fix errors that prevent successful reloading.

dash/dash-renderer/src/components/core · high confidence

Automated HTML component generation and build tooling

The build process for the dash-html-components package has been restructured to use a new set of Node.js scripts that automatically generate React components from MDN HTML specifications. This change introduces scripts to extract HTML attributes and elements, generate the corresponding React component files with correct PropTypes (including support for boolean and numeric prop types), and create the main index export. It also adds an ESLint configuration for the build scripts to allow Node.js module imports and console logging during the generation phase.

components/dash-html-components/scripts · high confidence

Calendar component rewritten with date-fns and improved accessibility

The calendar utility components have been completely rewritten to replace the previous moment.js dependency with date-fns, ensuring better performance and smaller bundle size. This change introduces improved localization support by detecting and applying user-preferred locales for month and day labels. Additionally, the calendar now features enhanced accessibility with proper focus management, keyboard navigation (arrow keys, page up/down, home/end), and correct CSS variable capture for portaled content, ensuring consistent styling and behavior when the calendar dropdown is rendered outside its parent container.

components/dash-core-components/src/utils/calendar · high confidence

Dash Core Components repository structure and configuration reset

The dash-core-components package has been restructured, introducing a new set of configuration files including .editorconfig, .eslintignore, .eslintrc, .flake8, .gitignore, .lib.babelrc, .npmrc, and .prettierrc to standardize code quality and build processes. A comprehensive .test\_durations file has been added to track integration test performance across components like DatePickers, Dropdowns, and Graphs, while the CHANGELOG.md has been updated to reflect historical changes up to v1.17.1 and note that future changes are recorded in the main Dash changelog. The package metadata (dash-info.yaml) and documentation (README.md, CONTRIBUTING.md) have been refreshed to align with current development workflows.

components/dash-core-components · high confidence

Dash Core Components rewritten in TypeScript with new components and UI updates

The Dash Core Components library has been rewritten in TypeScript, introducing a new centralized type definition file and a new entry point that exports a comprehensive set of components including Button, Checklist, DatePickerRange, DatePickerSingle, RadioItems, Textarea, and Tooltip. This migration brings several behavioral changes and new features: the Dropdown component now supports a search\_order prop to control result ordering, debounce functionality, and localizations; the Slider component adds support for reverse ordering and fixes regarding marks/steps options; the Input component has a fixed default autoComplete behavior; and the Link component now supports optional scroll-to-top behavior. Additionally, the Markdown component has been rewritten using updated libraries.

components/dash-core-components/src · high confidence

Dash Table core utilities and infrastructure refactored

The \components/dash-table/src/core\ directory has been restructured to introduce a suite of foundational utilities and services for the Dash Table component. This includes a new logging system (\core/Logger\) with configurable debug and log levels, a \Clipboard\ utility for handling copy/paste operations, and a \Stylesheet\ manager for dynamic CSS rule injection. Core logic for data handling has been centralized, featuring new modules for sorting (\core/sorting\), memoization (\core/memoizer\), and caching (\core/cache\). Additionally, the diff adds browser-specific helpers (\core/browser\), a syntax tree parser for filtering queries (\core/syntax-tree\), and various mathematical and generic utility functions (e.g., \arrayZipMap\, \objPropsToCamel\), establishing a robust internal API layer for the table's behavior.

components/dash-table/src/core · high confidence

IE11 compatibility and license update for dynamic import plugin

The @plotly/webpack-dash-dynamic-import plugin now supports Internet Explorer 11 by injecting a shim for \document.currentScript\ that falls back to scanning the script tag stack for non-async, non-inline scripts. This ensures dynamic chunk loading works in older browsers. Additionally, the plugin now prevents JavaScript code from being appended to CSS chunks generated by mini-css-extract-plugin, and includes a new MIT license file.

@plotly/webpack-dash-dynamic-import · high confidence

Introduces TypeScript type definitions for callbacks and components

The Dash renderer now includes formal TypeScript interfaces for callback definitions (including support for background, streaming, and dynamic callbacks) and component properties. This adds static typing for the callback execution lifecycle, payload structures, and the global \dash\_component\_api\ exposed to the browser, improving type safety and developer experience for the renderer's internal logic.

dash/dash-renderer/src/types · high confidence

Lazy loading of Dash Core Components via dedicated loader modules

The application now supports lazy loading for several Dash Core Components, including DatePickerRange, DatePickerSingle, Dropdown, Graph, Markdown, RangeSlider, Slider, and Upload. New loader modules have been added in the \components/dash-core-components/src/utils/LazyLoader\ directory to dynamically import the corresponding component fragments (e.g., \DatePickerRange\, \Dropdown\) only when needed. Additionally, a new loader for \plotly.js\ has been introduced, which dynamically injects the Plotly script from a configurable URL (\window.\_dashPlotlyJSURL\) with a 30-second timeout, ensuring that the visualization library is loaded on demand rather than at initial page load.

components/dash-core-components/src/utils/LazyLoader · high confidence

Loading spinners rewritten in TypeScript

The Loading component's spinner implementations (Circle, Cube, Default, Dot, and Graph) and their shared type definitions have been migrated from JavaScript to TypeScript. This change improves type safety and developer experience for the internal spinner components without altering the visual behavior or user-facing API of the Loading indicator.

components/dash-core-components/src/fragments/Loading · high confidence

Major component overhauls: new DatePickers, rewritten Dropdown, and enhanced Graph/Upload capabilities

This release significantly updates several core Dash components. The DatePicker component is replaced by new DatePickerSingle and DatePickerRange implementations built on Radix UI and date-fns, featuring improved accessibility, portal support, and robust date-range logic. The Dropdown component is rewritten as a custom Radix-based component with virtualized lists for performance, enhanced keyboard navigation, and new search ordering controls. The Graph component now includes improved event data handling (including customdata, x/y values, and bounding boxes), better responsive resizing, and fixes for animation frames and invalid figure handling. The Upload component gains support for folder uploads and multiple file drag-and-drop. Additionally, the Markdown component is rewritten in TypeScript with updated markdown libraries and GFM support.

components/dash-core-components/src/fragments · high confidence

Markdown rendering rewritten in TypeScript with GitHub Flavored Markdown support

The dcc.Markdown component's underlying rendering engine has been rewritten in TypeScript and updated to use modern markdown libraries, including the addition of the remark-gfm plugin. This enables native support for GitHub Flavored Markdown features such as tables, strikethrough, task lists, and autolinks. The rewrite also refines math rendering (supporting both inline and display modes via MathJax) and improves raw HTML handling by explicitly stripping script and style tags while allowing specific Dash components like dcc.Link within markdown content.

components/dash-core-components/src/utils/markdown · high confidence

New error boundary and global error container components

The renderer now includes dedicated React components for handling errors: ComponentErrorBoundary catches component-level failures and dispatches error actions, while GlobalErrorContainer wraps the application with a debug menu and error display (with a passthrough version for non-debug modes). Additionally, custom CSS styles are applied to Werkzeug traceback displays to improve the visual presentation of error messages in the browser.

dash/dash-renderer/src/components/error · high confidence

New observer-based callback lifecycle and WebSocket support

The renderer now uses a set of dedicated store observers (documentTitle, executedCallbacks, executingCallbacks, isLoading, prioritizedCallbacks, requestSlot, requestedCallbacks, storedCallbacks, and websocketObserver) to manage the callback lifecycle and UI state. This introduces support for WebSocket-based callbacks, allowing callbacks to be routed over a multiplexed WebSocket transport instead of individual HTTP requests, which reduces connection overhead. The system now enforces a concurrency limit (MAX\_CONCURRENT\_HTTP\_CALLBACKS) for HTTP-based callbacks while exempting clientside, streaming, and WebSocket-routed callbacks from this slot. Callback execution is more robust, with better handling of persistence pruning, patch analysis for efficient DOM updates, and improved error handling. The loading indicator now correctly excludes persistent callbacks. WebSocket connections are managed efficiently, opening lazily when needed and handling disconnection.

dash/dash-renderer/src/observers · high confidence

New unified CSS design system and component styles

This change introduces a comprehensive set of new CSS files for Dash Core Components, establishing a unified visual design system. It defines global CSS variables (e.g., --Dash-Fill-Interactive-Strong, --Dash-Spacing) in dcc.css to standardize colors, spacing, and shading across the library. New styles are provided for core components including Button, Input, Textarea, Dropdown, DatePicker, Calendar, Slider, Tabs, Checklist, RadioItems, and Tooltips, ensuring consistent appearance and behavior. The styles also incorporate fixes for third-party libraries like react-dates, react-select, and react-virtualized to ensure compatibility and correct rendering within the new design system.

components/dash-core-components/src/components/css · high confidence

Redesign of the Dash renderer state management architecture

The Dash renderer's state management has been restructured from a monolithic reducer into a modular, component-based architecture. This change introduces dedicated reducers for distinct application concerns—including app lifecycle, callback job tracking, dependency graphs, error handling, and layout history—combined via Redux's \combineReducers\. A new \layoutHashes\ mechanism tracks prop changes using path sums to optimize re-rendering performance, while the \config\ reducer now supports custom HTTP headers and stores children props on the window object for side effects. Additionally, the system now manages callback job states (add, remove, outdated) and exposes lifecycle hooks (pre/post layout, request, callback resolved) to allow for more granular control over the rendering and callback execution flow.

dash/dash-renderer/src/reducers · high confidence

Refactored component rendering and state management in the renderer wrapper

The Dash renderer wrapper has been rewritten to improve rendering performance and reliability. A new \DashContext\ provides \useLoading\ and \isLoading\ hooks for granular loading state tracking, while \DashWrapper\ now uses path-sum hashes to efficiently detect prop changes and avoid unnecessary re-renders. The introduction of \ExternalWrapper\ allows components outside the main layout tree to be managed correctly, and \CheckedComponent\ adds runtime prop-type validation. These changes ensure that component identity changes trigger remounts while prop updates reconcile in place, fixing issues with stale state and performance bottlenecks.

dash/dash-renderer/src/wrapper · high confidence

Refactored third-party library loading for syntax highlighting and math rendering

The codebase now uses dedicated TypeScript modules to manage the lazy loading of highlight.js and MathJax. Syntax highlighting is handled by a new module that explicitly registers a specific set of languages (including bash, csharp, python, sql, and others) via highlight.js, replacing previous generic loading. Math rendering utilizes a new lazy loader that respects a \mathjax\ configuration flag to conditionally load the tex-svg engine, while also checking for an existing global MathJax instance. These changes improve modularity and allow the Dash application to reuse existing global instances of these libraries if they are already present on the page.

components/dash-core-components/src/utils/LazyLoader/third-party · high confidence

Refactored webpack configuration and enabled filesystem caching for dash-table

The build configuration for the dash-table component has been restructured to improve maintainability and build performance. A new base webpack configuration file centralizes entry points, output settings, and module rules, while a separate preprocessing module standardizes build-time variable definitions. The output library configuration now uses an object format to explicitly define the library name and type. Additionally, filesystem caching has been enabled to speed up subsequent builds, and the jsx-runtime external is now shared and imported from the dash-renderer to ensure compatibility with older Dash versions.

components/dash-table/.config · high confidence

Renderer actions refactored to TypeScript with new Patch API and performance optimizations

The \dash/dash-renderer/src/actions\ directory has been migrated from JavaScript to TypeScript, introducing a new \Patch\ API that allows callbacks to partially update component props (e.g., \append\, \insert\, \assign\) instead of replacing entire objects, which improves performance and reduces network payload. The callback resolution logic has been optimized to use O(1) lookups for pattern-matching IDs (MATCH/ALL) via a new \objIndex\ in the paths store, and the dependency graph handling has been split into \dependencies.js\ and \dependencies\_ts.ts\ to reduce overhead. Additionally, the API layer now supports configurable CSRF cookie/header names and includes robust JWT retry logic for authentication refresh.

dash/dash-renderer/src/actions · high confidence

Renderer merges with DashPy and adds WebSocket, persistence, and React 19 support

The Dash renderer has been merged with DashPy, introducing a unified architecture that supports React 19 (via a compatibility shim), WebSocket callbacks, and a generalized component persistence system. Users can now leverage hooks for layout and request lifecycle events, benefit from improved error handling and prop-type validation, and utilize configurable CSRF tokens. The renderer also supports layout as a list of components, dynamic callbacks, and improved performance for context component re-rendering.

dash/dash-renderer/src · high confidence

Standardized base module for Dash HTML components

The base initialization module for the Dash HTML components library has been restructured to remove Python 2/3 compatibility shims and future imports. It now explicitly loads the package version from package-info.json, validates that the Dash framework is correctly installed (checking for plotly\_dash or development attributes), and configures the JavaScript distribution paths to point to the specific versioned release on unpkg.com.

_components/dash-html-components/dash\_html\_components\base · high confidence

Update pre-commit hook to use lint-staged

The pre-commit hook in .husky has been updated to execute lint-staged via npx, replacing the previous implementation. This change ensures that staged files are linted before each commit, with the --no-revert flag configured to prevent automatic reverting of changes if linting fails.

.husky · high confidence

Updated build configuration for React 19 and backward compatibility

The dash-html-components build process has been updated to support React 19 and ensure backward compatibility with older versions of Dash. This is achieved by externalizing the JSX runtime via a shared configuration and adjusting the webpack output library settings. Additionally, the project now uses the minified plotly.js distribution and enforces stricter linting rules to improve code quality and consistency.

components/dash-html-components · high confidence

Test coverage

Added TypeScript component test fixtures; Added TypeScript component test package; Added backend integration tests for Dash; Added comprehensive test suite for background callbacks; Added integration and unit tests for dash-html-components; Added integration and unit tests for the shared storage system; Added integration test assets for clientside callbacks; Added integration test for dcc.Tooltip behavior; Added integration tests for @mcp\_enabled decorator functionality; Added integration tests for Dash Button component; Added integration tests for Dash Core Components; Added integration tests for Dash DevTools; Added integration tests for Dash Graph component behavior; Added integration tests for Dash Tabs component behavior; Added integration tests for Dash core features; Added integration tests for Dash import consistency; Added integration tests for French locale support in DatePicker; Added integration tests for Location component navigation and callbacks; Added integration tests for XSS and URL injection protections; Added integration tests for asset filtering and external resource attributes; Added integration tests for async and background callbacks; Added integration tests for clientside callbacks; Added integration tests for dcc.Download component; Added integration tests for dcc.Link component behavior; Added integration tests for multi-page layout, ordering, and path handling; Added integration tests for multi-page routing and page registration; Added integration tests for option title attributes; Added integration tests for the Geolocation component; Added test asset styles for input and tab components; Added test assets for Dash callback grouping and standard app patterns; Added test assets for dash integration tests; Added test assets for upload component integration tests; Added test fixtures for asset path ignore functionality; Added test infrastructure and CI safety nets; Added test infrastructure for Dash Core Components; Added test suite for streaming callbacks and multiplexed transport; Added type-compliance tests for Dash callbacks; Added unit tests for Dash MCP tool integration; Added unit tests for Dash Pages configuration and path inference; Added unit tests for Dash Table clipboard, query syntax, and date handling; Added unit tests for MCP resource providers; Added unit tests for MCP server configuration, session management, and tool dispatch; Added unit tests for Markdown text utility functions; Added unit tests for app runners, background callbacks, and security signing; Added unit tests for component generation and metadata handling; Added unit tests for library grouping, validation, and serialization; Added unit tests for slider mark density logic; Added unit tests for the new Calendar component implementation; Expanded integration test coverage for Dash Graph component; Expanded integration test coverage for callback behaviors; Expanded integration test coverage for the Dash renderer; Integration tests for dcc.Markdown component; Integration tests for the MCP server feature.

Dependencies

Updated npm dependencies and lockfiles for Dash test components and tooling

Updated package manifests and lockfiles for several internal Dash packages, including \@plotly/dash-component-plugins\, \@plotly/dash-jupyterlab\, \@plotly/dash-websocket-worker\, \@plotly/eslint-config-dash\, and the generator test component suites (\standard\, \nested\, \typescript\). These changes refresh build tooling versions (such as Babel, Webpack, and ESLint) and resolve dependency trees to ensure consistent and secure builds for the test infrastructure.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 39.8 → 41.1 (+1.3)
  • Rubric changed (rubric-2026.11.2 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 64.0 → 63.1 (-0.9)
  • Architecture 68.5 → 68.3 (-0.2)
  • Maturity 58.2 → 61.6 (+3.4)
  • Readiness 39.1 → 40.1 (+1.0)
  • Security 56.6 → 68.7 (+12.1)
  • Accessibility 26.9 → 26.5 (-0.4)
  • Performance 88.6 → 88.6 (0.0)

Resolved (61)

  • Critical CVE: [GHSA redacted] (package-lock.json)
  • Dash._walk_assets_directory (cyclomatic 16) (dash/dash.py)
  • Deprecated: glob (package-lock.json)
  • Deprecated: uuid (package-lock.json)
  • Duplicated block (16–17 lines × 2) (dash/_callback.py)
  • FunctionTooLong: GraphSpinner.GraphSpinner (components/dash-core-components/src/fragments/Loading/spinners/GraphSpinner.tsx)
  • Further sole-owners (lower concentration)
  • High CVE: [GHSA redacted] (package-lock.json)
  • High CVE: [GHSA redacted] (package-lock.json)
  • High CVE: [GHSA redacted] (package-lock.json)
  • High CVE: [GHSA redacted] (@plotly/eslint-config-dash/package-lock.json)
  • High CVE: [GHSA redacted] (package-lock.json)
  • High secret: WD-SECRET-0005 (@plotly/dash-component-plugins/package-lock.json)
  • High secret: WD-SECRET-0005 (dash-renderer/package-lock.json)
  • High secret: WD-SECRET-0005 (package-lock.json)
  • Hotspot: dash/_pages.py (dash/_pages.py)
  • Leaked secret: hardcoded-credential (package-lock.json)
  • Leaked secret: hardcoded-credential (package-lock.json)
  • Low CVE: [GHSA redacted] (@plotly/dash-jupyterlab/yarn.lock)
  • Low CVE: [GHSA redacted] (components/dash-core-components/package-lock.json)
  • …and 41 more

New (116)

  • Dash._on_assets_change (cognitive 18) (dash/dash.py)
  • Edited copy of a member (10 corresponding lines) (dash/_shared_storage/local.py)
  • Edited copy of a member (104 corresponding lines) (dash/background_callback/managers/celery_manager.py)
  • Edited copy of a member (11 corresponding lines) (dash/_shared_storage/local.py)
  • Edited copy of a member (14 corresponding lines) (dash/backends/ws.py)
  • Edited copy of a member (16 corresponding lines) (dash/backends/_flask.py)
  • Edited copy of a member (16 corresponding lines) (dash/background_callback/managers/celery_manager.py)
  • Edited copy of a member (16 corresponding lines) (dash/testing/wait.py)
  • Edited copy of a member (19 corresponding lines) (dash/backends/ws.py)
  • Edited copy of a member (23 corresponding lines) (dash/backends/_flask.py)
  • Edited copy of a member (28 corresponding lines) (dash/dependencies.py)
  • Edited copy of a member (3 corresponding lines) (dash/_shared_storage/_polling.py)
  • Edited copy of a member (31 corresponding lines) (dash/backends/_flask.py)
  • Edited copy of a member (33 corresponding lines) (dash/backends/_flask.py)
  • Edited copy of a member (35 corresponding lines) (dash/_shared_storage/local.py)
  • Edited copy of a member (39 corresponding lines) (dash/backends/ws.py)
  • Edited copy of a member (6 corresponding lines) (dash/mcp/primitives/tools/input_schemas/input_descriptions/description_pattern_matching.py)
  • Edited copy of a member (89 corresponding lines) (dash/testing/application_runners.py)
  • Edited copy of a member (9 corresponding lines) (dash/testing/wait.py)
  • Flaky test: @plotly/dash-generator-test-component-typescript/generator.test.ts::Test Typescript component metadata generation Test component comments Component has docstring
  • …and 96 more

Changes since last survey

  • 48 commits — 33 feature/other, 15 fixes

By area

  • (repo) — 27 commits
  • (root) — 9 commits
  • .github/workflows — 2 commits
  • components/dash-core-components — 2 commits
  • dash/dash-renderer — 2 commits
  • @plotly/dash-component-plugins — 1 commit
  • @plotly/dash-generator-test-component-nested — 1 commit
  • components/dash-html-components — 1 commit
  • components/dash-table — 1 commit
  • dash/_callback.py — 1 commit
  • dash/backends — 1 commit

Notable commits

  • fix: Fix dcc.Upload contents and dcc.Geolocation position docstrings
  • fix: Merge branch 'dev' into fix-assets-css-extension
  • fix: Merge branch 'dev' into fix-assets-css-extension
  • fix: Merge branch 'dev' into fix/2958-preventupdate-sideupdates
  • fix: Merge branch 'dev' into fix/2958-preventupdate-sideupdates
  • fix: Merge branch 'dev' into fix/2958-preventupdate-sideupdates
  • fix: Merge branch 'dev' into fix/2958-preventupdate-sideupdates
  • fix: Merge branch 'dev' into fix/2958-preventupdate-sideupdates
  • fix: Merge branch 'dev' into fix/mcp-component-json-serialization-4113
  • fix: Merge pull request #4105 from Thanatos9404/fix-assets-css-extension
  • fix: Merge pull request #4114 from sushan5140/fix/mcp-component-json-serialization-4113
  • fix: Merge pull request #4128 from BSd3v/fix/2958-preventupdate-sideupdates
  • fix: Merge pull request #4148 from M-Colley/fix/wheel-only-ships-dash
  • fix: Merge remote-tracking branch 'upstream/dev' into fix-assets-css-extension
  • fix: fixes issues with set_props and callbacks that raise PreventUpdate
  • change: Add CHANGELOG entry for #4148
  • change: Add PR number to CHANGELOG
  • change: Add changelog entry
  • change: Bump the npm-dependencies group across 1 directory with 12 updates
  • change: Bump the npm-dependencies group across 1 directory with 13 updates
  • …and 28 more

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

plotly/dash 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.

About this page

  • The score is its most recent published measurement, taken on 16 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 572115cc34c21a56ee7d86af1fd143f547fd7afa — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.84+preprod-d645ca9bbedd.