quasarframework/quasar

This system is the Quasar framework ecosystem, centered on a modernized CLI and build toolchain that replaces legacy Webpack infrastructure with a Vite and Rolldown-based engine. It provides scaffolding and configuration for building Vue 3 applications across multiple deployment targets, including Single Page Applications, Server-Side Rendering, Static Site Generation, Progressive Web Apps, and native mobile or desktop wrappers via Capacitor, Cordova, and Electron. The system also includes a comprehensive UI component library and utilities for browser extensions, ensuring type-safe development and consistent developer experience through standardized templates and testing infrastructure.

28 changes.

This period focused on rewriting the Quasar CLI and build infrastructure to replace legacy Webpack tooling with a modern Vite and Rolldown engine. The work involved migrating the entire codebase to ESM, enforcing Node.js 20+ requirements, and implementing comprehensive testing via Vitest. It also introduced new build modes for SSR, PWA, Electron, Capacitor, and Browser Extensions, alongside updated templates using Vue 3 Composition API and Pinia.

38 changes.

The project migrated the Quasar CLI to an ESM format, replacing legacy implementations with Hono-based servers and modernized command handlers. Concurrently, the Vite build pipeline underwent significant restructuring, including a rewrite of the App Extension system, the introduction of a centralized caching proxy, and the addition of new utilities for SSL and SSR error handling. This period also saw the expansion of the UI framework with new plugins for browser control, metadata management, and improved SSR hydration support.

39 changes.

This period focused on migrating the Quasar CLI to Vite 3 as the default build system, introducing comprehensive TypeScript definitions and wrapper functions for improved type safety. It also added official support for Static Site Generation (SSG) and expanded SSR templates for multiple Node.js frameworks. The work was accompanied by a complete overhaul of the scaffolding engine, modernized tooling defaults, and extensive end-to-end testing to ensure stability.

A new AppVisibility plugin has been introduced to the Quasar framework, exposing a reactive \appVisible\ boolean property via the global \$q\ object. This property automatically updates to reflect whether the application currently has user focus by listening to the browser's \visibilitychange\ event, allowing developers to conditionally handle logic based on whether the app is in the foreground or background.

ui/src/plugins/app-visibility · high confidence

New store initialization templates using Pinia have been added for Vite-based Quasar applications. The diff introduces \app-vite/templates/store/pinia/js/index.js\ and \app-vite/templates/store/pinia/ts/index.ts\, which replace the previous store setup with a Pinia instance created via \createPinia()\. The TypeScript template also includes a declaration for \PiniaCustomProperties\ to support typing custom store properties, allowing users to easily integrate Pinia state management into their projects.

app-vite/templates/store · high confidence

New components have been added to the TypeScript playground (\app-vite/playground-ts\) to validate specific build capabilities. \JsxGreeting.tsx\ demonstrates that \.tsx\ files are correctly compiled against Vue's JSX runtime and that Quasar components accept standard props in TSX. \SharedStyleBadge.ts\ and its associated CSS file verify that styles from non-SFC modules are correctly hoisted into shared chunks when rendered across multiple pages, ensuring proper CSS handling in SSR/SSG contexts. Navigation components \DrawerLink.vue\ and \EssentialLink.vue\ provide the UI structure for the playground.

app-vite/playground-ts/src/components · high confidence

A new TypeScript-based playground application has been added to the Vite app-vite workspace. This includes a root App.vue component that renders router views, and an env.d.ts file that references Quasar client types and provides commented-out examples for defining custom environment variable types via ImportMetaEnv.

app-vite/playground-ts/src · high confidence

A new \client.d.ts\ file has been added to the \app-vite/exports/client\ location, providing TypeScript type definitions for the \ImportMetaEnv\ interface. This enables type-safe access to Quasar-specific environment variables such as \QUASAR\_MODE\, \QUASAR\_SSG\_MODE\, \QUASAR\_TARGET\, and \QUASAR\_VUE\_ROUTER\_MODE\ in client-side code, improving developer experience and reducing runtime errors when checking the application's build mode or platform.

app-vite/exports/client · high confidence

A new global CSS file (content.css) has been added to the BEX (Browser Extension) templates. This file provides a place for pure CSS styles that are used within the browser extension context, noting that it is not preprocessed.

app-vite/templates/bex/common · high confidence

Created empty .gitkeep files in the assets and boot directories of the app-vite/playground-ts project to ensure these folders are tracked in version control.

app-vite/playground-ts/src/assets, app-vite/playground-ts/src/boot · high confidence

A new private history plugin has been introduced to handle back-button behavior on Cordova and Capacitor platforms. It maintains an internal history stack that allows the application to intercept back presses, execute custom handlers for specific navigation states, and optionally exit the app or fall back to browser history based on configuration. A corresponding test file has been added to verify the plugin's structure and API availability.

ui/src/plugins/private.history · high confidence

This change introduces the core Capacitor mode implementation for the Quasar CLI using Vite, replacing the previous CLI-based approach. It adds dedicated modules for building (capacitor-builder.js), which handles Vite compilation and native builds for iOS and Android; a development server (capacitor-devserver.js) that manages the Vite server and Capacitor CLI integration; and installation logic (capacitor-installation.js) to scaffold the /src-capacitor directory and manage dependencies. The configuration handling (capacitor-config.js, config-file.js) now strictly requires capacitor.config.ts or capacitor.config.js, dropping support for the legacy capacitor.config.json, and dynamically manages the @jcesarmobile/ssl-skip package to handle SSL requirements for Capacitor versions 5 through 8.

app-vite/lib/modes/capacitor · high confidence

The app-vite package now exports an ESLint configuration via the 'eslint' entry point, available in both CommonJS (eslint.cjs) and ES Module (eslint.js) formats. This configuration provides a 'recommended' config that automatically ignores build artifacts and temporary files (such as 'dist/\', 'src-capacitor/\', 'src-cordova/\', '.quasar/\', and 'quasar.config.\.temporary.compiled\'), helping users avoid linting errors on generated content. The config is structured as a function to allow for future extensibility without breaking changes.

app-vite/exports/eslint · high confidence

This change introduces the new Quasar CLI based on Vite (@quasar/app-vite). Alongside the core CLI implementation, this release establishes a comprehensive testing framework using Vitest, including colocated unit tests for the library code and a dedicated end-to-end suite that validates the CLI against real playground applications (JS and TS templates) across all build modes, including SSR and Electron. The entry also includes the necessary configuration files (vitest.config.js, vitest-e2e.config.js) and global setup scripts to ensure the UI package is built before tests run, as well as documentation (AGENTS.md) and standard project files (LICENSE, README.md, .gitignore) to support the new package.

app-vite · high confidence

This change adds the @quasar/mcp package, a Model Context Protocol server that exposes the Quasar documentation and component API installed in your project. It works offline by reading bundled slices from quasar and @quasar/app-vite (available since quasar 2.33.0 and @quasar/app-vite 3.9.0), providing tools to list and search documentation pages, retrieve specific sections by route or heading, and inspect component props, slots, events, and methods. The server supports workspace roots with multiple apps, allowing agents to query specific apps by name, and gracefully handles older releases that only ship API descriptors without documentation pages.

mcp · high confidence

Adds the AppFullscreen plugin, exposing $q.fullscreen to manage browser fullscreen mode. The plugin provides reactive isActive and activeEl properties, along with request(), exit(), and toggle() methods that allow users to enter or exit fullscreen on a specific element or the document root. It includes a test suite with deterministic mocks for the Fullscreen API to ensure reliable testing across environments.

ui/src/plugins/app-fullscreen · high confidence

The app-vite exports now include a new \defineCapacitorConfig\ helper (available in both CJS and ESM) that wraps the standard Capacitor configuration to apply Quasar-specific defaults. This helper automatically sets the web directory to 'www' and configures the Android splash screen's \androidScaleType\ to 'CENTER\_CROP' to match Icon Genie's output, while ensuring user-provided values always take precedence. Additionally, when invoked within the Quasar CLI environment during development, it injects the correct dev server URL and enables cleartext traffic for Android builds, supporting both static config objects and dynamic factory functions.

app-vite/exports/capacitor · high confidence

The Quasar CLI now includes a new \app-vite\ module that replaces the legacy Webpack-based build system with a modern Vite and Rolldown engine. This change introduces a new build pipeline featuring a \quasar.config.js\ configuration file, support for \.env\ and \.env.local\ files, and a new \EntryFilesGenerator\ that creates mode-specific entry points (SPA, SSR, SSG, BEX, etc.) from templates. The new architecture includes an \AppBuilder\ for file operations, an \AppDevserver\ with a diff-based hot-reload system, and a \ConfigTools\ module that handles Vite and Rolldown configuration merging. It also adds a \NodeVersionCheck\ requiring Node.js 22.22.0 or higher, and a \TypesGenerator\ to auto-generate TypeScript definitions for the config and mode-specific files.

app-vite/lib · high confidence

A new Meta plugin has been added to the UI framework, enabling dynamic control over the browser's document head and body attributes. This plugin allows applications to programmatically update the page title, as well as inject, modify, or remove meta tags, link tags, and script tags. It also supports setting HTML and body attributes (excluding 'lang' and 'dir' for HTML, and 'class' and 'style' for body) to ensure proper document structure. The implementation includes utilities for encoding special characters to prevent injection issues and a diffing mechanism to efficiently apply only the necessary changes to the DOM.

ui/src/plugins/meta · high confidence

A new AddressbarColor plugin has been introduced, allowing applications to dynamically set the mobile browser's address bar color. The plugin injects a \set\ method into the global \$q\ object, which updates the \theme-color\ meta tag in the document head or utilizes the native \StatusBar\ API on iOS/Safari environments. It automatically applies the configured color during installation if \$q.config.addressbarColor\ is defined, and includes comprehensive unit tests to verify injection and method behavior.

ui/src/plugins/addressbar · high confidence

The create-quasar tool now includes a new scaffolding script for App Extensions that allows users to select specific features such as TypeScript support, prompts, install/uninstall scripts, and linting. When linting is enabled, the scaffolded project uses oxlint instead of previous linters, and the generated package.json is configured to use pnpm exclusively as the package manager.

create-quasar/templates/ae · high confidence

This change introduces the TypeScript type definitions for the BEX (Browser Extension) bridge, located in app-vite/types/bex. It adds bridge.d.ts which defines the BexBridge interface, BexEventMap for typed event communication, and BexBridgeOptions for configuring the bridge (background, app, or content script modes). It also adds entry point type declarations (background.d.ts, content.d.ts, create-bridge.d.ts) that export the createBridge function, and an index.d.ts to re-export the bridge types. This provides type safety for developers using the BEX bridge for communication between extension parts.

app-vite/types/bex · high confidence

This change introduces the core JavaScript modules for the Browser Extension (BEX) development experience in Chrome. The new \background.js\ and \content.js\ files establish a bridge between the extension and the Vite dev server, enabling Hot Module Replacement (HMR) by intercepting fetch requests and managing WebSocket connections for live reloads. This allows developers to see changes in their extension code instantly during development without manual reloading, specifically targeting the Chrome target environment.

app-vite/exports/bex · high confidence

This change introduces the core build infrastructure for the BEX (Browser Extension) mode in the Vite-based Quasar CLI. It adds a new builder that compiles the extension UI via Vite and background/content scripts via Rolldown, while automatically extracting script entries from the browser extension manifest (supporting both Manifest V2 and V3) and bundling the final output into a ZIP package using the fflate library. The dev server is updated to watch the manifest and scripts, enabling Hot Module Replacement (HMR) for extensions, and the installation logic now scaffolds the /src-bex directory with appropriate templates.

app-vite/lib/modes/bex · high confidence

The BEX (Browser Extension) templates now include \background.js\, \my-content-script.js\, and \manifest.json\ files configured for Manifest V3. The \manifest.json\ sets up the extension with \storage\ and \tabs\ permissions, defines a service worker for Chrome and script-based background for Firefox, and registers a content script. The \background.js\ and \my-content-script.js\ templates initialize the bridge communication using \createBridge\ and provide examples for handling events like logging, time retrieval, and local storage operations.

app-vite/templates/bex/js · high confidence

The utils area now includes the \art\ package, which generates a new Quasar CLI banner with a blue-to-red gradient (respecting \FORCE\_COLOR=0\ for raw text), and the \render-ssr-error\ package, which handles the display of SSR 500 errors in dev mode. Additionally, the \ssl-certificate\ and \update-notifier\ packages are introduced for internal use in generating localhost SSL certificates and managing update notifications, respectively. These utilities are bundled with the CLIs, so their behavior changes ripple into \cli\, \create-quasar\, and \app-vite\.

utils · high confidence

The app-vite/lib/utils directory has been populated with a comprehensive suite of new utility modules and their corresponding unit tests. These utilities provide core CLI functionality including argument parsing (get-argv, ensure-argv), environment variable handling (env), application path resolution (get-app-paths), and build target definitions (build-targets). The addition of these files introduces new behaviors for how the CLI validates commands, resolves project structures, and manages environment configurations, all backed by a new colocated Vitest test suite to ensure reliability.

app-vite/lib/utils · high confidence

The Cordova template now includes a new \index.html\ stub (\app-vite/templates/cordova/www/index.html\) that serves as the entry point for Vite-based Cordova applications. This file provides a basic HTML structure with standard meta tags (charset, description, viewport) and a simple CSS layout to center content, displaying a message indicating that the file is auto-generated and instructing users to run \quasar dev\ or \quasar build\ in Cordova mode.

app-vite/templates/cordova · high confidence

The Electron mode for Vite-based Quasar apps now provides new JavaScript templates for the main process (electron-main.js) and preload script (electron-preload.js). The main process template initializes the browser window with context isolation enabled and securely loads the preload script, while also registering the Quasar runtime helper. The preload script uses contextBridge to expose the 'quasarRuntime' object to the renderer process, ensuring secure communication between the main and renderer threads without direct Node.js access in the renderer.

app-vite/templates/electron/js · high confidence

Added main and preload runtime modules that provide utilities to resolve the electron-assets and public directories in both development and production environments. The main process exposes IPC handlers to synchronously return these resolved paths, while the preload script exposes corresponding functions and a \quasarRuntime\ object, allowing renderer processes to reliably access these paths regardless of the build mode.

app-vite/exports/electron · high confidence

Added new \playground-js\ and \playground-ts\ starter applications under \app-vite\ to demonstrate and test the Vite-based Quasar CLI. These playgrounds include full project scaffolding (HTML, config, source files) and feature-specific components—such as \JsxGreeting.jsx\ and \SharedStyleBadge.js\—to validate JSX/TSX support, shared CSS chunking, and filename-based routing in both JavaScript and TypeScript environments.

app-vite/playground-js · high confidence

The Loading plugin has been introduced as a new feature in the UI layer, providing a global overlay mechanism to indicate loading states. This implementation allows users to show and hide a loading spinner with customizable messages, colors, and delays via the $q.loading API. The plugin supports grouping to manage multiple concurrent loading states, prevents background scrolling when active, and includes a transition effect for smoother user experience. The change includes the core JavaScript logic, SASS styling for the loading overlay, JSON configuration metadata, and comprehensive test coverage.

ui/src/plugins/loading · high confidence

The Vite-based CLI now includes a dedicated PWA mode, introducing a new build pipeline that handles PWA-specific tasks such as manifest injection, service worker compilation via Workbox (supporting both GenerateSW and InjectManifest strategies), and UI bundling. This change adds new configuration files (pwa-config.js) to manage Workbox options and Vite settings, a builder (pwa-builder.js) to orchestrate the production build, and a devserver (pwa-devserver.js) that watches for changes in the manifest and service worker to trigger client reloads. Additionally, a new installation utility (pwa-installation.js) sets up the necessary directory structure (/src-pwa) and dependencies for PWA support, while utility functions handle manifest generation and HTML tag injection.

app-vite/lib/modes/pwa · high confidence

The \create-quasar\ tool now includes new JavaScript and TypeScript templates for App Extensions (AE) that standardize the developer experience by using \@clack/prompts\ for consistent installation questions. These templates provide a complete scaffold including install, uninstall, index, and prompt scripts, and demonstrate how to register a boot file and globally register a Vue component using the \\#q-app\ alias.

(repo-wide) · high confidence

This update introduces several new Vite/Rolldown plugins to the build pipeline. The \rolldown.inject-replacements\ plugin now injects shim values for \\_\dirname\, \\\_filename\, and \import.meta\ properties to support ESM environments. A \rolldown.virtual-entry\ plugin manages static imports for Electron main scripts, including a bootstrap mechanism to prevent deadlocks on circular imports. The \rolldown.vue-shim\ plugin provides empty shims for \.vue\ files in Node contexts. Additionally, the HTML template engine (\vite.html\) now handles undefined variables gracefully by displaying a warning page instead of failing, and the \vite.strip-filename-hashes\ plugin allows production builds to use stable filenames without hashes, which requires careful cache management for PWAs.

app-vite/lib/plugins · high confidence

A new \utils/render-ssr-error\ package has been introduced to handle 500 errors during server-side rendering in development. This utility generates a detailed HTML error page that includes the error name, message, a parsed stack trace with source code context, and request environment data (protocol, headers, cookies). It ensures security by escaping hostile markup to prevent XSS and explicitly avoids leaking shell environment variables into the rendered output.

utils/render-ssr-error · high confidence

Quasar now offers a new Server-Side Rendering (SSR) mode for the Vite app, replacing the previous implementation. This mode leverages Vite for the SSR server and client builds, and Rolldown for the webserver compilation. Key features include support for PWA in SSR mode, improved critical CSS injection that only includes styles for components rendered in the current request, and better handling of store state serialization (preserving Map, Set, Date, and RegExp). The build process now generates a \quasar.manifest.json\ for asset resolution and supports both ESM and CommonJS projects. Additionally, the dev server includes hot module replacement (HMR) for the client and webserver, with specific handling for CSR routes and PWA service workers.

app-vite/lib/modes/ssr · high confidence

The SSR mode now provides official starter templates for four Node.js web frameworks: Express, Fastify, Hono, and Koa. Each framework is supported in both JavaScript and TypeScript variants, featuring dedicated server entry points (e.g., \server.js\/\server.ts\) and render middlewares that handle Vue rendering, 404/500 error states, and redirects. The templates also include logic for serving static assets, generating preload tags for JS/CSS/fonts/images, and injecting Vite dev middleware, giving users a consistent, framework-specific foundation for server-side rendering.

app-vite/templates/ssr · high confidence

Quasar now supports a dedicated SSG mode that pre-renders Vue routes into static HTML files during the build process. This feature introduces a new build pipeline (ssg-builder.js) and configuration schema (ssg-config.js) allowing users to define which routes are statically generated versus client-side rendered via the ssg.clientSideRenderingRoutes option. The implementation includes a dedicated SSG renderer for server-side execution, a development server (ssg-devserver.js) for live preview with critical CSS injection, and CLI scaffolding (ssg-installation.js) to set up the necessary /src-ssg directory structure. Users can configure error handling strategies, retry logic, and concurrency settings to control the static generation process.

app-vite/lib/modes/ssg · high confidence

The TypeScript BEX (Browser Extension) templates now include a unified \manifest.json\ that supports both Chrome and Firefox via conditional keys, specifying \background.ts\ as a service worker for Chrome and a script for Firefox. The \background.ts\ template initializes the bridge via \createBridge()\ and provides examples for handling events like logging, time retrieval, and storage operations. The \my-content-script.ts\ template similarly initializes the bridge and demonstrates connecting to the background script and listening for events. These changes modernize the extension scaffolding with consistent TypeScript support and cross-browser compatibility.

app-vite/templates/bex/ts · high confidence

This change introduces a new set of TypeScript declaration files in the \app-vite/types/ssr\ directory to provide type safety for Server-Side Rendering (SSR) implementations. It defines the \QSsrContext\ interface for the SSR context object, including properties like \req\, \res\, \$q\, and \nonce\, as well as the \SsrDriver\ interface allowing users to augment server types. Additionally, it exports types for the SSR middleware lifecycle, including \SsrCreateParams\, \SsrMiddlewareParams\, and error handling interfaces (\SsrRenderRouteNotFoundError\, \SsrRenderRedirectError\), enabling better IDE support and type checking for custom SSR server setups.

app-vite/types/ssr · high confidence

This change introduces a comprehensive set of TypeScript declaration files for the Vite-based Quasar CLI, significantly improving type safety and developer experience. The new types cover App Extension APIs (including new methods like \hasTypescript\, \getStorePackageName\, and \getNodePackagerName\), precise path resolution helpers (\app-paths\), and wrapper functions for defining configuration, boot, prefetch, route, and store scripts. It also adds specific types for SSR and SSG modes, BEX (Browser Extension) support, and augments global types for Cordova and BEX bridges, ensuring that Vite users have robust autocomplete and compile-time checks for the Quasar framework.

app-vite/types · high confidence

Added new TypeScript template files for the Electron main process (electron-main.ts) and preload script (electron-preload.ts). The main process template now uses ESM-compatible imports, resolves the window icon path via a helper utility, and explicitly sets context isolation with a preload script path. The preload script template includes security warnings and exposes the Quasar runtime to the renderer process via contextBridge.

app-vite/templates/electron/ts · high confidence

A new user interface has been added to the \utils/render-ssr-error\ package to display Server-Side Rendering (SSR) 500 errors during development. This Vue-based UI features a dark-themed layout with a rotating logo, displaying the error name and message. It includes a scrollable stack trace list that allows users to select specific stack frames, a code viewer that highlights the relevant source lines using Prism.js, and an environment details table. The interface also provides direct links to open the error location in editors like VS Code, Sublime Text, or TextMate.

utils/render-ssr-error/src-ui · high confidence

The Electron and SPA modes now use dedicated Vite and Rolldown build pipelines, replacing the previous tooling. The Electron mode supports multiple preload scripts, forces CommonJS output for preloads to maintain sandbox security, and automatically injects the macOS Dock icon in development. It also handles pnpm workspace configurations by dynamically adding 'shamefullyHoist' to ensure dependency resolution during packaging. The SPA mode provides a streamlined Vite-only build process. Both modes feature new configuration hooks (e.g., \extendElectronMainConf\, \extendElectronPreloadConf\) and improved dev-server handling with specific file watching and reload mechanisms.

app-vite/lib/modes/electron · high confidence

The app-vite/templates directory now provides new scaffolding for Quasar applications built with Vite. These templates adopt the Vue 3 Composition API using the \\<script setup\>\ syntax for components and pages, and replace the legacy Vuex store with Pinia for state management. Additionally, boot files and SSR middleware are updated to import utilities from the new \\#q-app\ alias, streamlining the setup for developers starting new projects.

app-vite/templates · high confidence

The app-vite/templates/entry directory now provides the generated JavaScript entry points for the Vite build pipeline, replacing previous implementations. This includes app.js for core app creation and store/router injection, client-entry.js for browser-side bootstrapping and pre-fetch hooks, server-entry.js for server-side rendering logic, and specialized scripts for SSG (ssg-script.js) and SSR web servers (ssr-dev-webserver.js, ssr-prod-webserver.js). The templates also introduce bex-app.js for Browser Extension bridge initialization and ssr-nonce.js for Content Security Policy nonce handling, establishing the foundational runtime structure for Quasar apps using Vite.

app-vite/templates/entry · high confidence

The app-vite build system now uses a centralized caching proxy (createCacheProxy) to manage runtime and module state, ensuring that expensive operations like detecting TypeScript presence, resolving CSS variables, or loading package-specific modules (such as Pinia, Electron bundlers, Vue Devtools, and Vue Router) are executed only once and cached per proxy instance. This new module system includes dedicated handlers for detecting the active Node package manager (npm, yarn, pnpm, bun), managing Capacitor CLI versions, and handling Electron bundler installation, with concurrent calls safely deduplicated. Comprehensive unit tests have been added for all new cache modules to verify correct detection logic, caching behavior, and error handling.

app-vite/lib/cache · high confidence

A new internal package at utils/update-notifier has been introduced to manage version checks for long-lived processes. It exposes a public API (getAvailableUpdate, notifyUpdate) that checks the npm registry for newer stable versions, caches results, and renders a formatted terminal notification. The implementation includes logic to skip checks when offline, respects environment variables to disable notifications, and handles color output based on terminal capabilities.

utils/update-notifier · high confidence

A new internal package, \utils/ssl-certificate\, has been added to generate self-signed localhost SSL certificates. This utility creates certificates valid for 30 days, covering \localhost\, \localhost.localdomain\, \lvh.me\, \\*.lvh.me\, and local IPv4/IPv6 addresses. It ensures file permissions are restricted to 0o600 on non-Windows platforms and automatically regenerates certificates that are older than 30 days or lack proper permissions. Tests verify the certificate structure, key usage, and permission handling.

utils/ssl-certificate · high confidence

A new \wrappers.js\ file has been added to the \app-vite/exports\ directory, providing a set of identity wrapper functions (e.g., \defineConfig\, \defineBoot\, \defineRouter\, \defineStore\, and various SSR/SSG-specific definitions like \defineSsrMiddleware\ and \defineSsgGetPages\). These functions are no-ops at runtime but serve to apply TypeScript typings to callback parameters and return values, improving type safety and developer experience when using Quasar with TypeScript.

app-vite/exports · high confidence

The PWA template files in \app-vite/templates/pwa\ have been updated to support TypeScript. New \.ts\ versions of the service worker registration (\register-sw.ts\) and custom service worker (\sw/custom-sw.ts\) are provided alongside the existing JavaScript files, with the TypeScript service worker configuration extending \.quasar/tsconfig.pwa-sw.json\. The PWA manifest (\manifest.json\) has been updated to include additional icon sizes (up to 512x512) and specific purposes like \maskable\ and \monochrome\, and a Safari pinned tab SVG icon has been added.

app-vite/templates/pwa · high confidence

The playground application has been restructured to provide a modernized development environment. The main layout (App.vue) now features a fixed home button and a settings card that allows users to toggle dark mode, switch between RTL/LTR layouts, and dynamically select the Quasar language and icon set (including new Fontawesome v7 and SVG Ionicons v7/v8 options). The application entry point has been updated to use Vue 3 script setup syntax, and a new boot file (ssr-client.js) has been added to support SSR hydration testing. Additionally, the playground now includes comprehensive mock data for tree components and dedicated demo pages for various UI elements like Ajax Bar, Avatar, Badge, and Banner to facilitate easier component testing and exploration.

ui/playground · high confidence

The Screen plugin now exposes a reactive \orientation\ property that reflects the device's screen orientation (via the Screen Orientation API), including type, angle, and portrait/landscape status. Additionally, the plugin's behavior regarding the \bodyClasses\ configuration is now verified through new SSR hydration tests, ensuring that the server-rendered breakpoint class is correctly updated on the client after takeover.

ui/src/plugins/screen · high confidence

The Quasar CLI now provides comprehensive TypeScript definitions for the \quasar.config.js\ file, covering all build modes (SPA, SSR, SSG, PWA, Capacitor, Cordova, Electron, and BEX). This adds strict typing for configuration properties such as \build\, \devServer\, \framework\, and mode-specific options, enabling better IDE autocomplete and compile-time validation for project setups.

app-vite/types/configuration · high confidence

The TypeScript playground application now includes a dedicated router configuration file that initializes the Vue Router instance with support for history, hash, or memory modes based on environment variables, along with hot module replacement handling. Additionally, a generated type definition file is provided to enable strict typing for route names and parameters, ensuring better developer experience and type safety when navigating within the application.

app-vite/playground-ts/src/router · high confidence

The App Extension public API has been refactored from a single monolithic class into distinct classes for each lifecycle script: BaseAPI, IndexAPI, InstallAPI, PromptsAPI, and UninstallAPI. This change introduces new helper methods on the base API, including hasTypescript(), getStorePackageName(), and getNodePackagerName(), allowing extensions to detect the host project's configuration. The IndexAPI now exposes a prompts property for accessing user input and provides methods to manage persistent configuration (getPersistentConf, setPersistentConf, mergePersistentConf). InstallAPI and UninstallAPI gain specific capabilities to modify the host package.json (extendPackageJson) and clean up files (removePath), while all lifecycle APIs share common inspection utilities like hasPackage, hasExtension, and compatibleWith.

app-vite/lib/app-extension/api-classes · high confidence

The App Extension (AE) system in the Vite build pipeline has been significantly restructured. A new \AppExtensionInstance\ class now manages individual extension lifecycle, including robust name parsing for scoped packages and version suffixes, and resolves extension scripts by preferring \dist/\ over \src/\. The \quasar.extensions.json\ configuration is now handled by a dedicated \getAppExtJson\ utility that preserves file formatting (indentation) when updating, and strictly separates user prompts from internal state. Template rendering has been improved to handle undefined variables gracefully with a warning instead of failing, and binary file detection is now performed via a custom lightweight implementation rather than an external dependency. Additionally, a new per-extension logger provides branded output for better debugging.

app-vite/lib/app-extension · high confidence

The TypeScript and JavaScript App Extension templates have been updated to use pnpm workspaces (with a catalog for dependency versions) and oxlint for linting and formatting. This introduces new scripts (lint, lint:check, typecheck) and configuration files (oxlintrc, oxfmtrc) to the generated project structure, and updates the playground to use the workspace setup for easier AE development.

create-quasar/templates/ae/ts · high confidence

The Bottom Sheet plugin now passes a specific reason to the onCancel/onDismiss callbacks when the sheet is closed. Users can distinguish between dismissals triggered by clicking the backdrop (reason: 'backdrop'), pressing the ESC key (reason: 'escape'), or calling the hide() method programmatically (reason: 'programmatic'). This change is implemented in the BottomSheetComponent and its plugin registration, allowing for more precise handling of user interactions.

ui/src/plugins/bottom-sheet · high confidence

The CLI commands in \app-vite/lib/cmd\ (including \build\, \clean\, \dev\, \describe\, \ext\, \help\, \info\, \inspect\, and \mode\) have been rewritten as native ES modules. This introduces the \--no-color\ flag to all commands to disable colored output, replaces the \--nosummary\ flag with \--no-summary\ in the \build\ command, and adds the \--no-color\ flag to the \clean\ command. The \clean\ command now supports granular cleanup with \--entry\, \--cache\, \--dist\, and \--qconf\ flags. The \describe\ command now supports the \--computedProps\ flag to display API computed properties.

app-vite/lib/cmd · high confidence

The Capacitor template files in app-vite/templates/capacitor have been updated to provide a modern, environment-driven setup. A new common www/index.html serves as a minimal, auto-generated entry point, replacing previous versions that included Windows-specific meta tags and icons. Additionally, dedicated capacitor.config.js and capacitor.config.ts templates are now provided for JavaScript and TypeScript projects respectively, utilizing Quasar's defineCapacitorConfig helper to correctly inject the application ID and name.

app-vite/templates/capacitor · high confidence

The Cookies plugin has been modernized to use the Max-Age attribute instead of the expires attribute for setting cookie lifetimes. This change allows users to specify expiration using human-readable strings like '1d' or '15m' in addition to numbers (days), dates, or raw date strings. The plugin now correctly handles quoted cookie values and ignores malformed cookie encoding. The plugin is injected into $q.cookies and provides methods for getting, setting, checking existence, and removing cookies, with support for SSR/SSG contexts.

ui/src/plugins/cookies · high confidence

The Cordova mode now automatically handles platform-specific configuration requirements during development and builds. For Android, the \android:usesCleartextTraffic="true"\ attribute is automatically added to the AndroidManifest.xml during development to allow HTTP traffic, and removed during production builds. For iOS, when using HTTPS in development, the tool automatically patches the AppDelegate.m and WKWebView engine files to accept untrusted SSL certificates, preventing development server connection failures. These changes ensure smoother development workflows without manual configuration of platform-specific network settings.

app-vite/lib/modes/cordova · high confidence

The Dialog plugin has been updated to pass a specific reason string to the onCancel and onDismiss callbacks when a dialog is closed. This reason indicates how the dialog was dismissed: 'cancel' when the Cancel button is clicked, 'backdrop' when the overlay is clicked, 'escape' when the ESC key is pressed, or 'programmatic' when the dialog is hidden via the API. The onOk callback remains unchanged and continues to pass the selected value to onDismiss, allowing developers to distinguish between user confirmation and other dismissal methods.

ui/src/plugins/dialog · high confidence

A pre-commit hook has been added to the project to automatically run lint-staged on staged files before each commit. This ensures that code quality checks are performed consistently before changes are recorded in the repository, preventing linting errors from being committed.

.husky · high confidence

The \vite-plugin/playground\ now includes a comprehensive suite of demo components to verify the plugin's handling of various Single File Component (SFC) configurations and asset processing. The new \App.vue\ orchestrates views for Sass/SCSS variable injection, asset URL transformation (including native images and Quasar components like \QImg\ and \QChatMessage\), and diverse script setups. These include JavaScript and TypeScript variants using both the Options API (\\<script\>\) and Composition API (\\<script setup\>\), as well as Pug template support. The playground exercises specific edge cases such as aliased imports, mixed-case component usage, directive handling (\v-ripple\), and custom component extension, providing a robust environment for testing the plugin's transformation logic.

vite-plugin/playground · high confidence

The main CLI entry point (cli/bin/quasar.js) has been rewritten as an ES Module. It now handles argument parsing, displays version/help information, and defers execution to a locally installed Quasar CLI (supporting both ESM and legacy CJS formats) when running commands like dev, build, or serve within a project. It also includes an internal update notifier and respects the --no-color flag.

cli/bin · high confidence

Icon Genie has been rewritten as a standalone ESM package requiring Node.js \>= 22.22.0, replacing legacy dependencies with modern alternatives like kolorist for output and tinyglobby for file operations. The CLI now supports percentage-based padding, monochrome launcher layers for Android 13+ themed icons, and dark splashscreen variants. It includes a native Capacitor implementation (replacing @capacitor/assets), updated PWA launch images for the latest iPhones and iPods, and full support for @quasar/app-vite v2 and v3. The tooling also adds a comprehensive unit test suite and improved error handling for Windows paths and non-TTY environments.

icongenie · high confidence

The IconSet plugin has been updated to ensure deterministic rendering during Server-Side Rendering (SSR) and Static Site Generation (SSG). It now correctly handles SVG icon sets (such as \svg-material-icons\), ensuring that inline SVGs rendered on the server hydrate identically on the client without mismatches or console errors. This change introduces specific hydration fixtures and tests to validate that the icon set state is preserved across the server-client round-trip.

ui/src/plugins/icon-set · high confidence

The mode installation logic has been refactored to ensure that missing \package.json\ and \pnpm-workspace.yaml\ files are automatically generated for non-SPA modes (such as SSR, BEX, and Electron) when they are detected as absent, rather than failing or requiring manual intervention. This change introduces robust non-interactive support for the CLI, allowing commands like \quasar mode add\ to run in CI or piped environments by falling back to sensible defaults (e.g., Hono for SSR webserver) instead of hanging on prompts. Additionally, the \isModeInstalled\ check has been extracted into a standalone utility to improve code maintainability and consistency across the mode management system.

app-vite/lib/modes · high confidence

The app template now uses a new \create-quasar-script.js\ entry point that handles initial user prompts (such as package and product names) before dynamically importing and executing the specific build-system script. This change establishes Vite 3 as the default build system by delegating to \./vite-3/create-quasar-script.js\, while also setting the default development command to \quasar dev\.

create-quasar/templates/app · high confidence

The Lang plugin has been refactored to support server-side rendering (SSR) hydration, ensuring that RTL language packs correctly set the \<html\> dir and lang attributes on both server and client. New accessibility labels have been added to the language pack structure, including 'noValue' for QSlider/QRange, 'minimum'/'maximum'/'range' for QRange, 'resize' for QSplitter, and 'prevSlide'/'nextSlide' for QCarousel. The plugin now also exposes a 'formatNumber' hook for localized digits in QDate, QTime, and QPagination, and includes a 'getClosestIsoName' utility to map locales to the nearest available language pack.

ui/src/plugins/lang · high confidence

The Loading Bar plugin has been refactored to use Vue's Composition API, replacing the previous implementation with a reactive plugin structure that utilizes \shallowRef\ for the internal bar reference and \ref\ for configuration props. This change introduces a new \isActive\ boolean property that reflects the plugin's current state, allowing users to reactively track whether the loading bar is visible. The plugin continues to inject the API into \$q.loadingBar\ and supports configuration via \setDefaults\, but now relies on a dedicated \createReactivePlugin\ utility and a global node creation strategy for mounting the underlying \QAjaxBar\ component.

ui/src/plugins/loading-bar · high confidence

The Body plugin has been refactored to modernize the codebase and improve how platform-specific CSS classes are applied to the document body. It now correctly handles Android safe area insets by adding the \q-safe-area-padding\ class for native mobile wrappers (Capacitor/Cordova) when \androidStatusBarPadding\ is not explicitly disabled, while preserving the existing \q-ios-padding\ class for iOS. The plugin also ensures that body classes (such as \desktop\/\mobile\, \touch\/\no-touch\, and \platform-\*\) are accurately synchronized between SSR and client-side hydration, and honors the \screen.bodyClasses\ configuration to include viewport size classes during server-side rendering.

ui/src/plugins/private.body · high confidence

The \app-vite/bin/quasar.js\ script is introduced as the new executable entry point for the CLI. It automatically disables colored output when the \--no-color\ flag is passed or when running in a CI environment. The script now supports shorthand aliases for commands (e.g., \d\ for \dev\, \b\ for \build\) and handles version and help flags before delegating to the specific command implementations.

app-vite/bin · high confidence

The \app-vite/types/ssg\ module now exposes a comprehensive set of TypeScript definitions for the Static Site Generation (SSG) feature. This includes the \SsgParseVueRouterParams\ and \SsgParseVueRouterResult\ types, which define the interface for the \parseVueRouterRoutes\ helper, supporting features like \crawlIgnoreRoutes\ (picomatch patterns) and \routesDynamicParamsMap\ for dynamic segment expansion. Additionally, it defines \SsgGetPagesParams\ and \SsgGetPagesCallback\ to structure the custom page generation logic, along with \SsgGetFilenameBasedRoutes\ for file-system-based routing. These types ensure type safety when configuring SSG behavior in \quasar.config\.

app-vite/types/ssg · high confidence

The Vite 3 app template now uses a dedicated \create-quasar-script.js\ to handle project generation. This script introduces an interactive prompt allowing users to select features such as TypeScript, Sass, linting (with a choice between oxlint or ESLint), Vue Router filename-based routing, Pinia state management, and i18n. The script dynamically renders the corresponding base, CSS, and feature-specific templates based on these selections, ensuring the scaffolded project matches the user's configuration.

create-quasar/templates/app/vite-3 · high confidence

The create-quasar tool now uses a new standalone JavaScript entry point (create-quasar/bin/create-quasar.js) that replaces the previous implementation. This change introduces native Node.js argument parsing via parseArgs, enabling more robust handling of command-line options. Key behavioral updates include: the --defaults flag now explicitly sets overwrite to false if not specified, preventing accidental data loss; package manager detection is improved to correctly identify the running environment; and the webpack-4 template option has been removed in favor of modern defaults. The CLI also integrates an internal update notifier and supports multiple package managers (pnpm, yarn, npm, bun) with appropriate usage instructions.

create-quasar/bin · high confidence

The Notify plugin's CSS has been updated to account for Android safe area insets, ensuring that notifications positioned at the top or center of the screen do not overlap with device-specific UI elements like notches or status bars. This change improves usability on modern Android devices by pushing notifications into the visible safe area.

ui/src/plugins/notify · high confidence

The platform detection plugin has been completely rewritten to support Vue 3 reactivity, replacing the previous implementation with a new \Platform.js\ module that explicitly initializes all boolean properties (previously \undefined\ when false) and normalizes browser names like Edge to 'edge'. The new logic improves accuracy for Safari detection by requiring independent browser tokens and fixes iOS detection issues, while dropping support for obsolete platforms like BlackBerry and PlayBook. A corresponding \Platform.json\ metadata file documents the updated API, and comprehensive tests using Vitest and real browser environments ensure the new behavior is stable.

ui/src/plugins/platform · high confidence

The pages in the TypeScript playground app have been replaced with new Vue components. The main layout now uses a Quasar drawer for navigation, dynamically generating links from auto-routes. The index page demonstrates the new JSX/TSX support by rendering a TSX component alongside a store value, and includes navigation to a second page. A new catch-all page handles 404 errors, and the second page showcases shared style components and scoped CSS.

app-vite/playground-ts/src/pages · high confidence

The example store in the Vite playground has been updated to include a Map property in its state. This change specifically addresses issue \#11382, ensuring that Map instances (along with other non-JSON-serializable types like Set, Date, and RegExp) are correctly preserved when the application state is serialized during Server-Side Rendering (SSR) or Static Site Generation (SSG), rather than being lost or corrupted by standard JSON stringification.

app-vite/playground-ts/src/stores · high confidence

The QTable component's rows-per-page options now correctly respect the controlled pagination state. Previously, the available page size options might not have updated or behaved correctly when the pagination was managed externally via v-model. This change ensures that the dropdown of available rows-per-page values stays in sync with the parent component's pagination model, preventing inconsistencies when the table is used in a controlled manner.

ui · high confidence

The Quasar CLI has been migrated to an ESM format, replacing the previous implementation with new command handlers for create, help, info, serve, and upgrade. The 'create' command now directs users to the new scaffolding tools (e.g., \npm init quasar@latest\) and deprecates the legacy global install method. The 'serve' command has been rebuilt using the Hono framework instead of Express/h3, supporting native proxy files, history mode, and HTTPS. The 'upgrade' command has been rewritten to use a new node-packager abstraction, supporting Bun, PNPM, and npm, with improved registry handling and a modern output interface. Additionally, the CLI now supports the \--no-color\ flag across commands and displays network interface IPs in the 'info' and 'serve' commands when bound to 0.0.0.0.

cli/lib/cmd · high confidence

The create-quasar CLI has been refactored to support standalone installation and introduces a new templating engine with a 'raw' option for unescaped output. The project creation workflow now correctly detects the running package manager, preserves the .git folder when overwriting an existing directory, and pins the scaffolded repository's initial branch to 'main'. Additionally, the CLI adapts to newer @clack/prompts specifications and ensures that the --defaults flag sets overwrite to false if not explicitly specified.

create-quasar/lib · high confidence

The global Quasar CLI has been rewritten in ESM format (v2), introducing a new testing structure that includes colocated unit tests and end-to-end (e2e) tests using Vitest. The e2e suite is configured to boot local \quasar serve\ servers and scaffold real projects via \create-quasar\ against a local registry, ensuring the CLI defers correctly to local app CLIs (\@quasar/app-vite\/\@quasar/app-webpack\) and handles upgrades without relying on published packages. This change establishes the foundational test and module architecture for the new CLI version.

cli · high confidence

The CLI has been rewritten for v2 as an ESM module, raising the minimum Node.js version to 20.20.0 and replacing legacy dependencies with modern alternatives like kolorist for styling and native parseArgs() for argument parsing. A new node-packager system now supports Bun, pnpm, npm, and yarn, automatically detecting the manager via lock files and handling pnpm 11+ build script restrictions. The upgrade command has been reworked to fetch version lists directly from the npm registry for faster, more accurate updates, and the server command now displays all available network interface IPs.

cli/lib · high confidence

The Quasar Vite plugin has been modernized to an ESM-only package, requiring Vite 8+, @vitejs/plugin-vue 6+, and Node 20.19+. It introduces new configuration options including \devTreeshaking\ (defaulting to false) to control tree-shaking during development, and \astAutoImport\ (defaulting to true) to enable compile-time component resolution for exact source maps. The plugin now supports Sass/Scss \\<style module\>\ syntax, TSX scripts, and allows the use of \@use\ and \forward\ in Sass files. Performance is improved by loading import maps and Vue transform state only when needed, and by aliasing the Quasar package to its client build in dev mode to reduce HTTP requests. The plugin also includes hardened caching for closure files and better handling of residual Quasar imports to prevent full bundle bloat.

vite-plugin · high confidence

The @quasar/extras package build process has been completely rewritten to use modern Node.js ESM scripts (located in extras/build/) instead of the previous shell-based approach. This new system automatically generates SVG icon sets, TypeScript type definitions, and webfont exports for all supported icon libraries (including Font Awesome v7, Ionicons v8, MDI v7, and Bootstrap Icons) and animations. The build now runs in parallel across available CPU cores for significantly faster execution, automatically sorts output files for consistency, and generates the package README.md from a template based on the latest asset versions.

extras · high confidence

The repository has been restructured to standardize the developer experience across all packages. Formatting and linting have migrated from ESLint to oxfmt and oxlint, enforced via new configuration files (.oxfmtrc.json, .oxlintrc.json) and a pre-commit hook. The monorepo is now managed via pnpm, with a root workspace configuration and a new script to detect peer-dependency resolution conflicts. A comprehensive agent guide (AGENTS.md) and a root Vitest configuration have been added to streamline testing and AI-assisted development.

(repo-wide) · high confidence

The SSG renderer templates (ssg-renderer.js and ssg-renderer.ts) have been updated to allow the getSsgPages function to be asynchronous, enabling more flexible page discovery logic without breaking changes. Additionally, the templates now include support for filename-based routing via the getFilenameBasedRoutes helper, allowing developers to generate static pages based on their file structure rather than just the router configuration. The renderPreloadTag function remains available for customizing preload hints for assets like JS, CSS, and fonts.

app-vite/templates/ssg · high confidence

The BEX bridge in the Vite-based extension now automatically re-establishes connections after the browser terminates the background service worker (a requirement for Manifest V3). The bridge listens for a revival signal from the background script and reconnects any dropped ports, ensuring that communication between the app, content scripts, and background remains stable across background script restarts.

app-vite/exports/bex/private · high confidence

The JavaScript and TypeScript playground templates now use \vue-router/auto-routes\ for file-based routing, replacing the previous static configuration. The main layout includes a navigation drawer that dynamically lists child routes, and a new \DrawerLink\ component handles menu items. A catch-all \404\ page is now included for unmatched paths, and the router configuration supports history, hash, or memory modes based on environment variables. TypeScript templates additionally include generated type definitions for route safety.

create-quasar/templates/ae/js/BASE/playground, create-quasar/templates/ae/ts/BASE/playground · high confidence

The scaffolded Vite 3 JavaScript application templates have been refreshed to align with current Quasar v2 standards. The generated \package.json\ now targets Node.js 22/24/26 and includes Pinia v4 and Vue I18n v11 when those presets are selected. ESLint configurations have been migrated to the flat config format (eslint v10) with support for both ESLint and the new oxlint linters, and the router now utilizes vue-router's auto-routes for filename-based routing. Additionally, the templates include a VS Code MCP server configuration for AI assistance, updated browser targets via autoprefixer, and refined boilerplate for layouts, stores, and i18n boot files.

create-quasar/templates/app/vite-3/js · high confidence

The Electron template now includes a pnpm-workspace.yaml file that explicitly allows the 'electron' package as a built dependency. This ensures pnpm runs the necessary postinstall scripts to download the Electron binary, preventing installation failures in environments where such scripts are otherwise blocked.

app-vite/templates/electron/common · high confidence

The Dark plugin now correctly handles the 'auto' configuration when server-side rendering (SSR) or static site generation (SSG) is enabled. Previously, the server could not determine the user's OS color preference, leading to a flash of the light theme before the client took over. The plugin now renders the initial markup in light mode and marks the body with a specific attribute; once the client hydrates and takes control, it resolves the actual system preference and applies the dark theme if needed. This ensures a seamless transition without visual flickering for users with dark mode enabled in their operating system.

ui/src/plugins/dark · high confidence

Added e2e test suite for CLI project scaffolding and serve command; Added e2e test suite for Quasar Vite app playgrounds; Added e2e test suites for create-quasar scaffolding; Added e2e tests for the App Extension package lifecycle; Added test fixture for Quasar App Extension lifecycle; Added test fixture for ae-host-app; Added testing configuration export for @quasar/testing; Added unit and e2e testing infrastructure for create-quasar; Added unit tests for create-quasar CLI and scaffolding logic.

The TypeScript app template now scaffolds projects using TypeScript 6 (specified as ^6.0.0 in devDependencies) and Pinia 4 (specified as ^4.0.2 in dependencies). This change updates the underlying versions for the generated \package.json\ and aligns the template with the latest major releases of these libraries.

create-quasar/templates/app/vite-3/ts · high confidence

This update upgrades dependencies across 39 manifests in the monorepo, including security fixes for selfsigned (3 high vulnerabilities), express ([CVE redacted] in cookie), rollup ([CVE redacted]), http-proxy-middleware ([CVE redacted]), serialize-javascript, and js-yaml. It also upgrades Vite to 6.1+, Vue to 3.4.20, and updates icon sets such as MDI, Fontawesome, Ionicons, and Bootstrap Icons to their latest versions.

(dependencies) · high confidence

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

• CAI 35 → 48 (+13.7)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 65 → 62 (-3.6)
• Architecture 94 (new)
• Maturity 57 → 64 (+7.0)
• Readiness 13 → 49 (+35.3)
• Security 52 → 74 (+22.3)
• Accessibility 37 (new)

• (anonymous) (cognitive 19) (vite-plugin/src/scss-transform.js)
• (anonymous) (cyclomatic 16) (vite-plugin/src/scss-transform.js)
• Boundary-crossing change coupling: menu.js ↔ directives.js (docs/src/assets/menu.js)
• Change coupling: build.js ↔ prepare.js (app-vite/lib/cmd/build.js)
• Change coupling: generator.composable.js ↔ generator.generic.js (ui/testing/specs/generators/generator.composable.js)
• Change coupling: quasar.config.js ↔ quasar.config.ts (app-vite/playground-js/quasar.config.js)
• Change coupling: quasar.config.js ↔ quasar.config.ts (create-quasar/templates/app/vite-3/js/BASE/quasar.config.js)
• Change coupling: svg-eva-icons.js ↔ svg-material-icons.js (ui/icon-set/svg-eva-icons.js)
• Change coupling: svg-material-symbols-outlined.js ↔ svg-material-symbols-rounded.js (ui/icon-set/svg-material-symbols-outlined.js)
• Change coupling: svg-material-symbols-outlined.js ↔ svg-material-symbols-sharp.js (ui/icon-set/svg-material-symbols-outlined.js)
• Change coupling: svg-material-symbols-rounded.js ↔ svg-material-symbols-sharp.js (ui/icon-set/svg-material-symbols-rounded.js)
• Dimension evaluation failed
• FileTooLong: components/DocApiEntry.js (docs/src/components/DocApiEntry.js)
• FileTooLong: lib/quasar-config-file.js (app-vite/lib/quasar-config-file.js)
• FileTooLong: specs/astParser.js (ui/testing/specs/astParser.js)
• FileTooLong: specs/specs.utils.js (ui/testing/specs/specs.utils.js)
• FileTooLong: specs/testFile.js (ui/testing/specs/testFile.js)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 75 more

• Banned license: potrace
• Change coupling clique: index.d.ts, index.d.ts, index.d.ts (extras/exports/material-symbols-outlined/index.d.ts)
• Change coupling: bex-bridge.js ↔ my-content-script.js (app-vite/exports/bex/private/bex-bridge.js)
• Change-coupling hub: TouchPan.js → ScrollFire.js, TouchHold.js, TouchRepeat.js, TouchSwipe.js (ui/src/directives/touch-pan/TouchPan.js)
• Change-coupling hub: quasar-config-file.js → entry-files-generator.js, bex-utils.js, pwa-config.js, vite.html.js (app-vite/lib/quasar-config-file.js)
• Coverage not measured — JavaScript/TypeScript suite
• Documentation: no contributor guidance (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no project overview (README.md)
• Documentation: no usage examples (README.md)
• 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 314 more

• 300 commits — 221 feature/other, 79 fixes

• ui/src — 92 commits
• docs/src — 84 commits
• docs/build — 23 commits
• create-quasar/templates — 20 commits
• mcp/src — 10 commits
• (root) — 9 commits
• icongenie/lib — 8 commits
• docs/src-pwa — 5 commits
• extras/exports — 5 commits
• ui/test — 4 commits
• app-vite/lib — 3 commits
• docs/public — 3 commits
• icongenie/package.json — 3 commits
• utils/update-notifier — 3 commits
• .github/workflows — 2 commits
• app-vite/package.json — 2 commits
• cli/package.json — 2 commits
• create-quasar/package.json — 2 commits
• docs/quasar.config.js — 2 commits
• ui/lang — 2 commits

• fix: chore: fix lint in utils/is
• fix: fix(Dark): resolve 'auto' on SSR/SSG clients once they take over #7530
• fix: fix(QDrawer): keep iOS Safari's edge navigation swipe out of the drawer gestures
• fix: fix(QDrawer): keep mini-mode items put when the standard layout takes over #18320
• fix: fix(QEditor): editing a link a second time nested a new one inside it
• fix: fix(QEditor): hint the URL scheme instead of pre-filling it (#11450)
• fix: fix(QExpansionItem): settle a group sibling closed before its content ref is assigned (fix #18547)
• fix: fix(QFabAction): restore the fallback state when used outside a QFab (#18538)
• fix: fix(QField): a text color class in a custom standout now colors the content too (#16019)
• fix: fix(QField): forward focus from the control slot wrapper to the control #12648
• fix: fix(QField): readonly fields reflect focus like native readonly controls #16056
• fix: fix(QField): stop compositing one layer per field on Chromium #16024
• fix: fix(QInfiniteScroll): decide the first load at mount, not from the observer's opening report #18542
• fix: fix(QMenu): close on a press whose compatibility mousedown got suppressed #12575
• fix: fix(QMenu/QDialog): let the portal opening over a closing one take focus #8211
• fix: fix(QMenu/QTooltip): a flipped popup's cap keeps the bound the popup already has #18536
• fix: fix(QMenu/QTooltip): keep a flipped popup capped so growth can't escape the viewport (#18537)
• fix: fix(QMenu/QTooltip): the JS engine writes its inset from the anchored edge, so a growing popup grows away from its anchor
• fix: fix(QPage): keep the children's vertical margins inside the page #9536
• fix: fix(QPagination): the input field clears once the page is submitted (#18552)
• …and 280 more

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

quasarframework/quasar 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.