UdashFramework/udash-core

Udash is a Scala-based full-stack web framework that enables shared code between client and server through a reactive property system and type-safe RPC/REST communication. It provides a comprehensive set of Bootstrap 4 UI components with reactive state management, alongside robust features for authentication, internationalization, and client-side routing. The system supports both JVM and JavaScript targets, leveraging Atmosphere for real-time connections and Sttp for HTTP operations, while generating OpenAPI specifications for API documentation.

76 changes.

This period focused on establishing the Udash framework's foundational architecture, including a new routing engine, a refactored property system, and a modernized RPC subsystem using Atmosphere. It simultaneously introduced a comprehensive suite of Bootstrap 4 UI components and enhanced the REST module with OpenAPI generation and streaming support.

25 changes.

This period focused on building the Udash Guide from scratch, implementing a new backend with Jetty 10, Monix concurrency, and RPC/REST endpoints to serve documentation and interactive demos. The frontend was redesigned with responsive ScalaCSS styling, syntax highlighting, and a new homepage featuring live code previews. Supporting work included adding OpenAPI generation tests, a Jetty-based REST client with streaming support, and Selenium end-to-end tests to verify the new guide infrastructure.

This change introduces the JVM-specific implementation for the i18n module, adding \ResourceBundlesTranslationTemplatesProvider\ to load translations from \java.util.ResourceBundle\ files and \TranslationRPCEndpoint\ to expose these translations via RPC. The provider caches translation bundles by language, computes MD5-based hashes for change detection, and validates that templates do not mix indexed and unindexed placeholders. Tests verify correct retrieval of translations for multiple languages, bundle hashing consistency, and RPC behavior including efficient updates that skip sending unchanged bundles.

i18n/.jvm · high confidence

Added new JMH benchmarks for the Udash REST API, including \RestApiBenchmark\ for standard JSON and binary endpoints, \StreamingRestApiBenchmark\ for streaming responses with various batch sizes (10 and 500), and \MergeArraysBenchmark\ for array merging performance. These benchmarks allow users to measure throughput for small, medium, and huge response sizes in both JSON and binary formats.

benchmarks · high confidence

The guide application now includes its core static assets: an HTML entry point (\index.html\) that loads the frontend scripts and styles, a Less stylesheet (\assets.less\) that inlines Prism CSS and imports Bootstrap and Font Awesome, and introductory documentation content (\pages/intro.md\). Additionally, new SVG diagrams illustrating REST API serialization and type requirements have been added to support the guide's documentation.

guide/guide/.js · high confidence

The guide now supports syntax-highlighted code blocks. This change adds the PrismJS library (version 1.15.0) and its default CSS theme to the project assets, and introduces a \CodeBlock\ Scala component that leverages Prism to highlight code snippets for languages including CSS, JavaScript, Java, and Scala.

guide/commons/.js · high confidence

This change introduces the foundational resource files for the guide backend module, including English and Polish translation properties for authentication and error messages, a Logback configuration for console logging, and a reference configuration file defining the server port (8080) and static resource bases for the UI.

guide/backend/src/main/resources · high confidence

Added a new suite of benchmarks in the \io.udash.benchmarks.properties\ package to measure the performance of Udash properties. The suite includes \BenchmarkUtils\ with helper methods and model definitions, alongside specific benchmark suites for \SinglePropertyListeners\, \ModelPropertyListeners\, \ModelPropertyWithSeqListeners\, \FilteredSeqPropertyListeners\, \ReversedSeqPropertyListeners\, \TransformedSeqPropertyListeners\, \ZippedSeqPropertyListeners\, and \PropertyParameters\. These benchmarks evaluate set, get, and listen operations on direct, transformed, filtered, reversed, and zipped properties, including comparisons between BSeq and ISeq in model properties.

benchmarks/.js/src/main/scala/io/udash/benchmarks/properties · high confidence

A new shell script (authors.scala) has been added to the scripts directory that generates a list of contributors along with their commit counts, lines added, and lines deleted between two specified git tags. This tool allows users to quickly view project activity and authorship statistics directly from the command line.

scripts · high confidence

The benchmarks module now includes a new entry point and specific test suites for JavaScript. This adds benchmarks for ModelProperties with different Seq types (including transformed, filtered, reversed, and zipped sequences) and introduces new benchmarks for static translation bindings, measuring performance for both immediate and future-based translations.

benchmarks/.js/src/main/scala/io/udash/benchmarks · high confidence

The guide's style demonstration area now includes new Scala source files that define reusable CSS styles and animation keyframes. These additions provide concrete examples for users, including a color-pulse animation, mixin-based animation helpers, styled button variants (default, success, and animated), a toggle switcher component with state-based visibility, and responsive media queries for desktop and tablet views.

guide/shared/src/main/scala/io/udash/web/guide/styles/demo · high confidence

The \io.udash.bootstrap\ package now includes \UdashBootstrap\ and \package.scala\ to provide Bootstrap 4 styling and FontAwesome integration. Users can load Bootstrap 4 styles via \UdashBootstrap.loadBootstrapStyles()\ and FontAwesome styles via \UdashBootstrap.loadFontAwesome()\. The package also exposes \BootstrapStyles\ and \BootstrapTags\ for styling components, along with utility properties like \True\, \False\, and \ColorSecondary\.

bootstrap4/.js/src/main/scala/io/udash/bootstrap · high confidence

The \io.udash.bootstrap.utils\ package now includes comprehensive Bootstrap 4 CSS class definitions (via \BootstrapStyles\) and FontAwesome 5 icon support (via \UdashIcons\), enabling users to apply Bootstrap utility classes and FontAwesome icons directly in their Scala UI code. Additionally, \BootstrapImplicits\ provides implicit conversions for URL attributes and modifier handling, while \BootstrapTags\ exposes standard Bootstrap data attributes, and \UdashBootstrapComponent\ offers a base trait for managing jQuery event bindings in Bootstrap components.

bootstrap4/.js/src/main/scala/io/udash/bootstrap/utils · high confidence

Added a new \JettyRestClient\ implementation for the Udash REST module, replacing the previous \RawRest.Async\ approach with Monix \Task\. This client supports both standard request/response interactions and streaming responses, allowing users to process large data payloads incrementally without buffering the entire body in memory. Streaming is automatically activated when the server response lacks a \Content-Length\ header, enabling handling of chunked transfer encoding for both JSON lists and raw binary data.

rest/jetty/src/main · high confidence

This change adds the ModelProperty, ReadableModelProperty, and their implementation classes to the properties model package, providing a new way to handle nested data structures. Users can now create properties based on traits representing data models and access child properties via subModel, subProp, and subSeq methods (and their read-only counterparts roSubModel, roSubProp, roSubSeq), which are implemented via macros to ensure correct type inference and performance.

core/src/main/scala/io/udash/properties/model · high confidence

This change introduces the \io.udash.rest.raw\ package, providing a new low-level REST API implementation built on Monix \Task\ and \Observable\. It adds support for streaming responses via \StreamedRestResponse\ and \StreamedBody\ (handling raw binary, JSON lists, and single bodies), and introduces raw data types \JsonValue\ and \PlainValue\ for direct handling of JSON and form/query parameters. The package includes core abstractions like \HttpBody\, \Mapping\/\IMapping\ for headers/parameters, and \RawRest\ for resolving and handling REST calls, enabling developers to build REST servers and clients with fine-grained control over HTTP bodies and streaming.

rest/src/main/scala/io/udash/rest/raw · high confidence

The utils module now provides foundational utilities for application development, including a cross-platform logging abstraction (CrossLogger/CrossLogging) for consistent logging across environments, a CallbacksHandler for managing and executing registered callbacks with exception swallowing, and FilteringUtils for efficiently finding equal prefixes and different suffixes between iterators. Additionally, a Registration trait and its implementation are introduced to manage the lifecycle of registered callbacks, allowing users to cancel, restart, and check the active status of registrations.

utils/src/main · high confidence

The macros module now includes several new macro implementations that enhance compile-time code generation. StyleMacros provides macros for defining CSS styles, keyframes, and font faces, integrating with scalacss. PropertyMacros handles the creation of model properties from traits and case classes, validating structure and generating necessary property accessors. ComponentIdMacro generates unique IDs for components based on their fully qualified class names. AllValuesMacro allows retrieving all public members of a specific type from an object at compile time. RestMacros materializes RPC and OpenAPI metadata for REST implementations. TestMacros provides utilities for testing type errors. These macros collectively improve type safety and reduce boilerplate in CSS styling, property management, component identification, and REST API definitions.

macros · high confidence

The library now includes new components for Bootstrap 4, specifically UdashBadge (with support for link badges and pill styles), UdashBreadcrumbs (with default and text-based factories), UdashJumbotron (with fluid layout support), and UdashListGroup (with flush style support). These components are generated with unique component IDs by default and integrate with the existing Udash binding system for reactive content updates.

(repo-wide) · high confidence

This release introduces a suite of new UI components for Bootstrap 4, including \UdashButton\ (supporting button, anchor, and div tags with toggle capabilities), \UdashButtonGroup\ (with reactive, checkbox, and radio modes), \UdashButtonToolbar\, \UdashCard\ (featuring a factory for headers, footers, images, and nested lists/navs), \UdashCollapse\, \UdashAccordion\, and \UdashModal\. These components provide reactive state management for active/disabled states, dynamic content rendering via nested interceptors, and integration with Bootstrap's jQuery plugins for events and animations.

bootstrap4/.js/src/main/scala/io/udash/bootstrap/button · high confidence

Added \CssFileRenderer\ and \CssStringRenderer\ classes in the \css/.jvm\ module to provide explicit control over how CSS stylesheets are output. \CssFileRenderer\ writes styles to individual files in a specified directory and optionally generates a \main.css\ entry point that imports all other stylesheets, while \CssStringRenderer\ concatenates styles into a single string. These components wrap the underlying \scalacss\ rendering logic to offer structured output options for JVM-based applications.

css/.jvm · high confidence

The utils module now includes CrossCollections, providing a set of factory methods and helpers to create and manipulate JavaScript-native collections (arrays, dictionaries, maps, sets) as mutable buffers, along with operations like copying and slicing. Additionally, the URLEncoder has been moved to this location and updated to accept explicit boolean parameters (spaceAsPlus for encoding, plusAsSpace for decoding) to control how spaces are handled, allowing users to choose between standard URL encoding and form-encoding behavior.

utils/.js/src/main/scala/io/udash/utils · high confidence

Adds the \CssView\ trait in the \css/.js\ module, providing implicit conversions and extension methods that integrate Udash CSS styles with Scalatags. This enables users to apply CSS styles directly to DOM elements via Scalatags modifiers and manage styles reactively using \styleIf\ for boolean conditions or \reactiveApply\/\reactiveOptionApply\ for dynamic style factories based on properties. The change includes comprehensive tests verifying correct class list manipulation, prefix handling, and null-safety during reactive updates.

css/.js · high confidence

Added FileService to convert byte arrays to closeable object URLs and read file slices asynchronously or synchronously, and introduced FileUploader to POST files with optional extra data and custom request headers while exposing upload progress and response details via model properties.

core/.js/src/main/scala/io/udash/utils · high confidence

This change introduces several new components to the JVM-specific utils module: a UdashLogger implementation wrapping Typesafe Logging for structured logging, a CrossCollections object providing wrappers for Avsystem's mutable collections (arrays, maps, sets, and sequence replacement), a URLEncoder/Decoder with configurable space handling, and an AsyncUdashSharedTest trait for asynchronous testing with retry support.

utils/.jvm · high confidence

A new \UdashLogger\ class has been added to the \io.udash.logging\ package for the JavaScript platform. This implementation bridges Udash's logging interface to the browser's native \console\ API, supporting debug, info, warn, and error levels with optional parameters and exception causes.

utils/.js/src/main/scala/io/udash/logging · high confidence

The REST framework now generates OpenAPI 3.0.2 compliant documentation, introducing a new \GeneratedSchemaName\ typeclass and \@schemaName\ annotation that allow developers to explicitly control the names of schemas in the generated specification without altering serialization behavior. This change also adds support for defining OpenAPI tags with descriptions via annotations and ensures that nullable enum schemas correctly list \null\ as a valid value, improving the accuracy of the generated API documentation for consumers.

rest/src/main/scala/io/udash/rest/openapi · high confidence

The REST framework now provides a set of annotations in the \io.udash.rest.openapi.adjusters\ package that allow developers to customize the generated OpenAPI specification. New \SchemaAdjuster\, \ParameterAdjuster\, \OperationAdjuster\, \PathItemAdjuster\, and \TagAdjuster\ traits enable fine-grained control over the output. Convenience annotations like \@title\, \@description\, \@schemaDescription\, and \@bodyDescription\ are available to set metadata on schemas, parameters, operations, and request bodies respectively. Additionally, generic \adjustSchema\, \adjustParameter\, \adjustOperation\, \adjustPathItem\, and \adjustTag\ classes allow for custom logic via function arguments.

rest/src/main/scala/io/udash/rest/openapi/adjusters · high confidence

A new OpenApiServlet component has been added to the REST library, allowing users to easily expose their API's OpenAPI specification as a JSON endpoint. The servlet automatically renders the specification based on the provided metadata and configuration options such as info, components, servers, security requirements, and tags, making it simpler to integrate API documentation into web applications.

rest/.jvm/src/main/scala/io/udash/rest/openapi · high confidence

The Guide demo application now includes a structured set of RPC and REST interfaces to support interactive examples. This adds RPC traits for ping/pong, client ID logging, notifications, exception handling (including translatable errors), and complex GenCodec serialization (case classes, sealed traits, and custom codecs). It also introduces REST API definitions for simple data retrieval and echo functionality, along with the necessary exception registry and internationalization keys to support these demo features.

guide/shared/src/main/scala/io/udash/web/guide/demos · high confidence

This change introduces several new utility classes in the RPC subsystem to enhance functionality and ease of use. CallLogging is added as a mixin to simplify RPC call logging, allowing developers to easily track method invocations and arguments. DefaultAtmosphereFramework provides a pre-configured Atmosphere setup with sensible defaults for WebSocket support, session handling, and broadcasting. Additionally, FileDownloadServlet and FileUploadServlet are introduced as abstract templates to streamline the implementation of file download and upload endpoints, handling MIME types, content disposition, and file part processing out of the box.

rpc/.jvm/src/main/scala/io/udash/rpc/utils · high confidence

The guide homepage now features a dedicated landing page that includes an interactive demo section. Users can view live code previews for 'Hello, World!' and 'Select' components directly on the site, with source code displayed alongside the rendered output. The page also includes standard sections highlighting framework features like shared Scala code, type-safety, and reactive bindings, along with navigation to documentation and changelogs.

guide/homepage/.js · high confidence

A new UdashCarousel component has been added to the io.udash.bootstrap.carousel package, providing a reactive carousel widget for Bootstrap 4. This component allows users to display a sequence of slides with configurable indicators, animation options, and accessibility labels (srTexts). It exposes methods to control the carousel programmatically (cycle, pause, goTo, nextSlide, previousSlide) and emits events for slide transitions, integrating with Udash's property system to keep the active slide index in sync with the underlying data structure.

bootstrap4/.js/src/main/scala/io/udash/bootstrap/carousel · high confidence

The UdashDropdown component has been introduced to provide a reactive dropdown menu for Bootstrap 4. It supports dynamic item rendering via a configurable item binding factory, allowing for flexible content such as text, links, buttons, headers, dividers, raw DOM elements, and custom dynamic factories. The component exposes lifecycle events (Show, Shown, Hide, Hidden, Selection) and allows customization of the toggle button, menu alignment, and drop direction.

bootstrap4/.js/src/main/scala/io/udash/bootstrap/dropdown · high confidence

Added \UdashNav\ and \UdashNavbar\ components to the Bootstrap 4 navigation module. \UdashNav\ provides a generic navigation list supporting tabs, pills, alignment, and vertical layout, while \UdashNavbar\ offers a responsive navigation bar with dark/light themes, background colors, and fixed/sticky positioning. Both components accept a \componentId\ for DOM identification and allow custom content via \elemFactory\ (for nav items) and \navigationFactory\ (for navbar content), enabling flexible integration of custom UI elements within the navigation structure.

bootstrap4/.js/src/main/scala/io/udash/bootstrap/nav · high confidence

A new \UdashPagination\ component is now available in the \io.udash.bootstrap.pagination\ package, providing a Bootstrap 4-styled pagination UI. It supports configurable page sequences, active page highlighting, and optional previous/next navigation arrows. The component allows customization of page item rendering and arrow labels via factory functions, and automatically manages the selected page index when the underlying page sequence changes.

bootstrap4/.js/src/main/scala/io/udash/bootstrap/pagination · high confidence

The auth module now provides three new components to simplify access control. AuthApplication adds a withDefaultRoutingFailureListener extension method that automatically redirects users to a specified state when an UnauthorizedException or UnauthenticatedException occurs during routing. AuthPresenter introduces an abstract base class for presenters that automatically checks user permissions and authentication status via the handleState method, with an optional requireAuthenticated flag. AuthView adds view helper methods (require, requireAuthenticated, requireWithFallback, requireAuthenticatedWithFallback) that conditionally render UI content based on user permissions and authentication status, with support for fallback views when access is denied.

auth/.js/src/main · high confidence

The routing module now includes a new \RoutingEngine\ that manages application state changes by resolving URLs to states and rendering views, exposing a \onStateChange\ callback for observing navigation events. It introduces \UrlChangeProvider\ implementations (\WindowUrlFragmentChangeProvider\ and \WindowUrlPathChangeProvider\) to handle URL fragment and path-based routing respectively, including click handling for anchor tags in the path provider. A \RoutingRegistry\ trait is provided for mapping URLs to states, and a \UrlLogging\ mixin is added to simplify logging navigation events.

core/.js/src/main/scala/io/udash/routing · high confidence

This change introduces a new \ComponentId\ class that allows components to automatically generate unique DOM element IDs based on their enclosing class, supporting suffixes for hierarchical naming. It also adds a \Listenable\ trait and \ListenableEvent\ interface, providing a standardized way for components to expose and manage event callbacks with registration, cancellation, and restart capabilities.

core/.js/src/main/scala/io/udash/component · high confidence

The i18n module now provides a new set of core components for handling translations in Udash applications. It introduces \LocalTranslationProvider\ for frontend-only apps using local bundles, and \RemoteTranslationProvider\ for apps using RPC, which includes optional browser storage caching with TTL support. The \Translations\ trait and its extension methods (e.g., \translated\, \translatedDynamic\, \translatedAttr\) allow binding translated strings to DOM elements and attributes, automatically updating when the application language changes. This replaces the previous translation mechanism with a more flexible, provider-based architecture.

i18n/.js/src/main/scala/io/udash/i18n · high confidence

This change introduces a comprehensive set of new input binding components in the \io.udash.bindings.inputs\ package, enabling two-way data binding for various HTML form elements. Users can now bind properties to text inputs (including text, password, number, date, time, and datetime-local), text areas, checkboxes, radio buttons, range sliders, file uploads (single and multiple), and select dropdowns (single, optional, and multi-select). The implementation includes shared infrastructure like \InputBinding\, \GroupedButtonsBinding\, and \SelectBinding\ to handle event listeners, debouncing, and dynamic option updates, providing a consistent API for integrating UI inputs with Udash properties.

core/.js/src/main/scala/io/udash/bindings/inputs · high confidence

The auth module now provides a structured permission system allowing developers to define granular access controls. Users can create custom permissions identified by a unique ID, which are evaluated via a \UserCtx\ context. The new \AuthRequires\ utility enables declarative checks, throwing \UnauthenticatedException\ or \UnauthorizedException\ when requirements are not met. Permissions can be combined using logical operators (\and\, \or\) or factory methods (\allOf\, \anyOf\) to build complex access rules, with a default codec registry ensuring these exceptions are serializable across RPC boundaries.

auth · high confidence

The guide now includes a new set of style utilities in the \io.udash.web.commons.styles.utils\ package. This adds \CommonStyleUtils\ for centering and transitions, \MediaQueries\ for responsive breakpoints (desktop, tablet, phone), and \StyleConstants\ defining body width, colors, and layout sizes. It also introduces \UdashFonts\ to configure and load the Roboto font family with various weights and styles, replacing previous ad-hoc styling approaches.

guide/shared/src/main/scala/io/udash/web/commons/styles/utils · high confidence

The guide packager now includes a default configuration file that sets up the embedded UI server to listen on port 8080 and serves the guide and homepage resources from the specified UdashStatics paths.

guide/packager · high confidence

The guide now exposes a dedicated RPC service, MarkdownPageRPC, allowing clients to request the content of specific guide pages (such as Intro, Rest, and License) by name. This change introduces the server-side contract for fetching markdown content, supporting the migration of REST documentation into the guide structure.

guide/shared/src/main/scala/io/udash/web/guide/markdown · high confidence

The UdashTooltip and UdashPopover components have been updated to allow passing a DOM node directly as the content or title, in addition to strings and functions. This change also introduces a new TooltipEvent enum that exposes Bootstrap lifecycle events (Show, Shown, Hide, Hidden, Inserted) to the application, enabling users to react to tooltip and popover state changes. The underlying implementation now uses a unified TooltipUtils base class to handle these options and event bindings for both tooltips and popovers.

bootstrap4/.js/src/main/scala/io/udash/bootstrap/tooltip · high confidence

The JavaScript REST client implementation has been updated to use the Sttp library (version 3) instead of the previous backend. The default backend is now explicitly configured as FetchBackend, meaning HTTP requests made via the REST client will now rely on the browser's native Fetch API.

rest/.js · high confidence

The homepage and guide UI styling has been restructured into modular Scala CSS files (e.g., \HomepageDefaultStyles\, \ButtonsStyle\, \DemoStyles\, \HeaderStyles\) to improve maintainability and fix layout issues. Key changes include fixing the homepage body width for mobile devices, adjusting header height and logo behavior on tablet/phone screens, and refining button and demo component styles with specific media queries for phones, tablets, and desktops. The Roboto font is now explicitly applied to guide elements, and unused style utilities have been removed.

guide/shared/src/main/scala/io/udash/web/homepage · high confidence

The backend guide application has switched its concurrency model from the default global scheduler to Monix's computation scheduler and now uses a dedicated fixed-thread pool (32 threads) for backend execution contexts. This change ensures that the guide's server-side operations run on a controlled, isolated thread pool rather than relying on shared global resources, which improves stability and resource management for the documentation site.

guide/backend/src/main/scala/io/udash/web · high confidence

The REST module now provides new \DefaultSttpBackend\ and \RestServlet\ components built on sttp3 and Monix, replacing previous implementations. The \RestServlet\ introduces configurable request payload size limits (default 16MB), customizable streaming batch sizes for JSON lists, and an optional \cancelOnDisconnect\ feature to cancel handler tasks when clients disconnect. It also supports raw data handling, binary HTTP bodies, and improved error logging for client-side stream cancellations and connection drops.

rest/.jvm/src/main/scala/io/udash/rest · high confidence

The Bootstrap 4 alert module now provides \UdashAlert\ and \DismissibleUdashAlert\ components, replacing the previous implementation. \UdashAlert\ renders a standard alert with configurable color styles, while \DismissibleUdashAlert\ adds a close button that triggers a \dismissed\ state change and allows programmatic dismissal via the \dismiss()\ method. Both components integrate with jQuery for lifecycle management and support dynamic content rendering through a nested interceptor.

bootstrap4/.js/src/main/scala/io/udash/bootstrap/alert · high confidence

A new Attributes object has been added to the guide's shared code, providing a centralized set of constants for common UI states (such as Hidden, Active, Disabled, Checked, and Expanded) and a helper function to generate data- attributes. This change supports the ongoing effort to remove jQuery dependencies from the DemoComponent by offering a lightweight, framework-agnostic way to manage element states and data attributes within the guide.

guide/shared/src/main/scala/io/udash/web/commons/styles/attributes · high confidence

The guide's backend has been restructured to serve demonstration applications and documentation content via new RPC and REST endpoints. This change introduces server-side implementations for various demo scenarios, including RPC ping/pong, client ID tracking, notifications, exception handling, and generic codec serialization. It also adds a Markdown content endpoint that parses Markdown files with Table of Contents support and serves them as HTML, alongside REST interfaces for simple data and echo operations. These components are wired together in the main RPC and REST interface classes to support the interactive guide experience.

guide/backend/src/main/scala/io/udash/web/guide · high confidence

The guide's visual presentation is now driven by newly introduced Scala-based CSS definitions in \DefaultStyles.scala\ and \GlobalStyles.scala\. These files establish a CSS reset, apply the Roboto font family, and define responsive typography and layout rules for headings, blockquotes, and links. They also provide utility styles such as clearfix, body padding adjustments for desktop/tablet/phone breakpoints, and specific styling for interactive elements like underline links, ensuring a consistent look and feel across the guide's components.

guide/shared/src/main/scala/io/udash/web/commons/styles · high confidence

The guide's visual presentation has been updated with a new set of ScalaCSS styles that define the layout for the header, side menu, and content areas. This includes a fixed header and a side menu that becomes a slide-out drawer on tablet and phone screens, ensuring the guide remains usable on smaller devices. Typography has been standardized to use the Roboto font, and code blocks now feature monospaced fonts with specific background colors and padding for better readability.

guide/shared/src/main/scala/io/udash/web/guide/styles/partials · high confidence

The guide's user interface now uses a new set of style definitions for key layout components. This includes styles for the footer (with responsive adjustments for phone and tablet views), header buttons (including social links and tooltips), header navigation (with a slide-in mobile menu for tablet portrait mode), and the mobile menu toggle button itself. These changes ensure consistent styling and responsive behavior for the guide's header, footer, and navigation elements.

guide/shared/src/main/scala/io/udash/web/commons/styles/components · high confidence

The ViewRenderer component has been rewritten to improve performance and correctness when managing nested views. It now uses a single-path rendering algorithm that avoids linear list appends when finding the common prefix of view hierarchies, resulting in faster updates. The logic for clearing child views and handling non-empty application roots has been refined to ensure proper cleanup during rerendering, preventing stale DOM elements or view states from persisting incorrectly.

core/.js/src/main/scala/io/udash/view · high confidence

The UdashProgressBar and UdashTable components have been updated to accept and render a \componentId\ parameter on their root DOM elements. This change allows users to explicitly identify these components in the DOM, which is necessary for proper accessibility attributes and external scripting integration. The progress bar now uses this ID for its main wrapper, and the table component applies it to the root table element, ensuring consistent ID management across Bootstrap 4 UI components.

bootstrap4/.js/src/main/scala/io/udash/bootstrap/progressbar, bootstrap4/.js/src/main/scala/io/udash/bootstrap/table · high confidence

The form components in the Bootstrap 4 module have been refactored to provide a more flexible and robust validation experience. The new \UdashForm\ component introduces configurable \ValidationTrigger\ options (such as \OnBlur\, \OnChange\, and \OnSubmit\) to control when inputs are validated, and utilizes a \FormElementsFactory\ to manage the lifecycle of form bindings. A new \Validator\ trait and \ValidationResult\ types (\Valid\/\Invalid\) standardize validation logic, while \UdashInputGroup\ now supports dynamic sizing and helper methods for prepending/appending content. This change simplifies the creation of complex forms with consistent validation feedback and layout control.

bootstrap4/.js/src/main/scala/io/udash/bootstrap/form · high confidence

The RPC subsystem has been refactored to remove the dependency on the legacy RpcFramework abstraction. This change introduces a new AtmosphereService that directly integrates with the Atmosphere framework to handle WebSocket, SSE, and polling transports, alongside a new DefaultAtmosphereServiceConfig for managing client connections and a BroadcastManager for efficient server-to-client messaging. The refactoring also includes new DefaultClientRPC and ExposesServerRPC implementations to streamline how server-side RPCs are exposed and how client-side calls are proxied, simplifying the overall RPC architecture for users.

rpc/.jvm/src/main/scala/io/udash/rpc · high confidence

The RPC subsystem has been refactored to migrate away from the legacy RpcFramework, introducing new base traits for exposing local RPCs (ExposesLocalRPC) and using remote RPCs (UsesRemoteRPC). The change establishes a new companion object hierarchy (ServerRpcCompanion, ClientRpcCompanion, and their Default variants) to manage RPC instances and metadata, alongside a raw RPC protocol layer (rawrpc.scala) defining message types like RpcCall and RpcFire. Additionally, new serialization utilities have been added, including a default Udash serialization implementation, an exception codec registry for handling remote errors, and JSON escape utilities, fundamentally changing how RPC interfaces are defined and serialized.

rpc/src/main · high confidence

The RPC subsystem has been refactored to replace the previous RpcFramework with a new architecture centered on DefaultServerRPC and DefaultAtmosphereServerConnector. This change introduces a ConnectionStatus enum (Open/Closed) that allows clients to monitor and react to connection state changes via callbacks, improving reliability during network interruptions. The implementation now relies on the Atmosphere framework for transport, supporting both WebSocket and Server-Sent Events (SSE) with automatic reconnection logic, while maintaining a 30-second default call timeout and configurable exception handling.

rpc/.js/src/main · high confidence

The sequence property implementation has been rewritten to use a new \Patch\ case class that explicitly tracks added and removed child properties by index, replacing the previous index-based removal logic. This change introduces a \ForwarderReadableSeqProperty\ base trait to unify the listener initialization and lifecycle management for derived properties like \FilteredSeqProperty\, \TransformedSeqProperty\, and \ZippedSeqProperty\. The refactoring ensures that element updates are processed before listeners are notified and that structure patches are consistent, preventing issues such as infinite loops in \SeqPropertyFromSingleValue\ and incorrect patch indices during transformations.

core/src/main/scala/io/udash/properties/seq · high confidence

The data-binding modifier system in the core library has been restructured to support generic nested interceptors and improved DOM manipulation. A new \Binding\ trait introduces a \NestedInterceptor\ mechanism, allowing bindings to manage nested dependencies and cleanup more effectively. The \SeqPropertyModifier\ and \SeqPropertyWithIndexModifier\ now handle \DocumentFragment\ updates and index tracking more robustly, fixing issues with batched updates and empty sequence initialization. Additionally, \SimplePropertyModifier\ and \ValueModifier\ have been simplified to create text nodes directly, reducing overhead. These changes improve the reliability of dynamic list rendering and property bindings.

core/.js/src/main/scala/io/udash/bindings/modifiers · high confidence

The i18n binding implementation has been restructured to treat basic translations as modifiers rather than bindings, introducing new classes like AttrTranslationModifier, DynamicAttrTranslationBinding, and DynamicTranslationBinding. This change enables dynamic attribute translation updates when the language changes and supports parsing translated text into DOM nodes, including raw HTML content via a new parseTranslation utility.

i18n/.js/src/main/scala/io/udash/i18n/bindings · high confidence

The i18n module has been refactored to support remote translation loading via a new \RemoteTranslationRPC\ trait, allowing clients to fetch translation bundles and templates from a server. Translation keys are now strongly typed case classes (\TranslationKey0\ through \TranslationKey9\ and \TranslationKeyX\) that support up to nine arguments, replacing the previous flat string-based approach. The \TranslationProvider\ implementation has been updated to handle null templates gracefully and now supports regex special characters in replacement arguments, ensuring safer text substitution.

i18n/src/main · high confidence

The property system now uses a centralized PropertyCreator and Blank typeclass mechanism to instantiate properties, replacing previous implicit-based creation logic. Immutable properties are now handled via dedicated ImmutableProperty and ImmutableSeqProperty classes that do not fire change listeners. Callback updates are batched using a new CallbackSequencer to avoid redundant listener invocations during bulk property changes.

core/src/main/scala/io/udash/properties · high confidence

The single-property module has been restructured to introduce \CastableProperty\ for safer, compile-time-checked casting between property types (e.g., to Model or Seq properties), and to replace the previous \transform\ mechanism with bidirectional \bitransform\ and \sync\ methods that allow two-way synchronization between properties. The update also introduces \MirrorProperty\ for creating mutable copies that follow an origin's updates, and refactors internal forwarding logic in \CombinedProperty\ and \TransformedProperty\ to improve listener management and value change detection.

core/src/main/scala/io/udash/properties/single · high confidence

The \Application\ class now accepts \RoutingRegistry\ and \ViewFactoryRegistry\ directly instead of using a container state or view factory, and provides a \goTo\ method with a \replaceCurrent\ flag to allow replacing the current history entry instead of pushing a new one. Routing failures are now handled via a dedicated \onRoutingFailure\ listener, and the \redirectTo\ and \changeUrl\ methods use the \Url\ type. The \io.udash\ package has been simplified to expose core types and utilities, removing deprecated components and the Bootstrap-only component from the default API.

core/.js/src/main/scala/io/udash · high confidence

The core view system now includes a StaticViewFactory and EmptyPresenter to optimize static views by preventing unnecessary rerendering through class-name comparison. Additionally, both View and Presenter interfaces now expose an onClose callback, allowing components to perform cleanup when they are replaced or removed from the view hierarchy.

core/.js/src/main/scala/io/udash/core · high confidence

The REST module has been refactored to use STTP 3 as the underlying HTTP client, replacing the previous implementation. This introduces a new \SttpRestClient\ that supports both \Future\ and Monix \Task\ backends, allowing users to configure request options such as timeouts. The API definition model has been updated with new companion base classes (\DefaultRestApiCompanion\, \RestDataCompanion\, \RestDataWrapperCompanion\) that automatically derive \GenCodec\ serialization and OpenAPI metadata, simplifying the setup of REST clients and servers. Additionally, the framework now supports streaming responses and raw body types, providing more flexibility for handling binary data and large payloads.

rest/src/main/scala/io/udash/rest · high confidence

The UdashDatePicker component now initializes options and default dates in a single request to avoid stack overflows, and uses a MutationObserver optimized for DOM nodes instead of IDs to handle dynamic content. Date change events are now correctly fired, and the component supports custom DOM detach handlers to properly clean up jQuery event listeners when the picker is removed from the DOM.

bootstrap4/.js/src/main/scala/io/udash/bootstrap/datepicker · high confidence

The \produce\ method now has a unified signature that works for both single properties and sequence properties, replacing the previous separate \produce\ and \SeqProperty\-specific variants. Additionally, \showIfElse\ has been reimplemented internally to use \produce\, simplifying the binding logic. This change also introduces a simpler variant of \showIf\ and ensures that \produce\ and \produceWithNested\ correctly respect custom DOM node replacement in unit tests.

core/.js/src/main/scala/io/udash/bindings · high confidence

The CSS module now includes \CssText\, which allows CSS styles to be applied directly to Scalatags text nodes via an implicit conversion, enabling seamless styling in HTML generation. The underlying \CssStyle\ model has been extended to support \commonPrefixClass\ and \classNames\, allowing styles to emit multiple CSS classes (e.g., for FontAwesome support like "fa fa-adjust"). Additionally, the \CssBase\ DSL and rendering logic have been updated to align with the \scalacss\ internal API changes, ensuring correct generation of styles, keyframes, and font faces.

css · high confidence

The guide's backend server has been upgraded to Jetty 10, enabling support for JSR 356 websockets via the JavaxWebSocketServletContainerInitializer. This change also replaces the legacy GzipHandler with the newer CompressionHandler and normalizes resource base paths to ensure static assets are served correctly. Additionally, the server now configures specific virtual hosts for the guide (including guide.udash.local) and integrates Atmosphere for RPC communication over websockets.

guide/backend/src/main/scala/io/udash/web/server · high confidence

Added CSS style application benchmark; Added JVM RPC subsystem tests; Added Jetty-based REST client integration tests; Added OpenAPI generation tests for REST APIs; Added REST client and server example code; Added RPC serialization and integration tests; Added comprehensive test coverage for core frontend components; Added comprehensive test suite for the Udash REST framework; Added core test utilities and base traits; Added frontend tests for authentication routing, presenters, and views; Added frontend unit tests for Bootstrap 4 UI components; Added integration and unit tests for the Udash REST server and client; Added shared test base traits for Udash testing; Added test infrastructure for Udash RPC backend; Added test utilities for asynchronous and frontend testing in Scala.js; Added tests for CallbacksHandler, FilteringUtils, and URLEncoder; Added tests for OpenAPI schema generation and dependency injection; Added tests for RPC internals and logging behavior; Added tests for RPC message serialization and server-side RPC handling; Added tests for TranslationKey functionality; Added tests for UdashForm validation triggers; Added tests for i18n bindings and translation providers; Added tests for raw REST mapping and server implementation; Enable Selenium-based end-to-end testing for the Udash Guide; Expanded test coverage for Udash properties core.

The project now includes \package.json\ and \package-lock.json\ to manage Node.js dependencies, specifically adding \jsdom\ (v27.0.1) and \ws\ (v8.21.0). These dependencies support the build and test environment, likely for running JavaScript-based tests or server-side rendering tasks within the CI pipeline.

(dependencies) · high confidence

The project establishes its build infrastructure by defining the core Scala version (2.13.18) and SBT version (1.13.0). It introduces a centralized dependency management file that specifies versions for key libraries including AVSystem Commons (2.30.0), sttp (3.11.0), Jetty (12.1.13), and Scala.js (1.22.0), alongside essential plugins for Scala.js, packaging, and CI release.

project · high confidence

This change establishes the initial structure of the Udash repository, adding the Apache 2.0 license (replacing the previous GPL v3 license), a comprehensive .gitignore file for various IDEs and build tools, and a .scala-steward.conf to manage dependency updates. It also includes a README.md describing the framework's features and badges, and configures Scala Steward to pin the Atmosphere library version and group Jetty updates.

(repo-wide) · high confidence

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

• CAI 43 → 44 (+0.9)
• Rubric changed (rubric-2026.09.15 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 37 → 41 (+4.0)
• Architecture 56 → 55 (-1.2)
• Maturity 68 → 67 (-0.5)
• Readiness 35 → 33 (-1.7)
• Security 81 → 81 (-0.1)
• Performance 81 (new)

• Boundary-crossing change coupling: Dependencies.scala ↔ DefaultAtmosphereFramework.scala (project/Dependencies.scala)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Off-boarding risk: anonymized user #1
• Outdated (npm): jsdom
• Outdated (npm): ws

• Hotspot: rest/.jvm/src/main/scala/io/udash/rest/RestServlet.scala (rest/.jvm/src/main/scala/io/udash/rest/RestServlet.scala)
• Medium CVE: [GHSA redacted] (project/Dependencies.scala)
• Off-boarding risk: anonymized user #1
• Outdated: ch.qos.logback:logback-classic
• Outdated: org.atmosphere:atmosphere-runtime
• Outdated: org.eclipse.jetty.compression:jetty-compression-gzip
• Outdated: org.eclipse.jetty.compression:jetty-compression-server
• Outdated: org.eclipse.jetty.ee8.websocket:jetty-ee8-websocket-javax-server
• Outdated: org.eclipse.jetty:jetty-client
• Outdated: org.eclipse.jetty:jetty-rewrite
• Outdated: org.webjars:bootstrap
• Outdated: org.webjars:font-awesome
• Projects may be oversized for their cohesion
• RestServlet.service (cognitive 28) (rest/.jvm/src/main/scala/io/udash/rest/RestServlet.scala)
• RestServlet.service (cyclomatic 19) (rest/.jvm/src/main/scala/io/udash/rest/RestServlet.scala)

• 23 commits — 22 feature/other, 1 fixes

• (repo) — 10 commits
• rest/.jvm — 8 commits
• project/Dependencies.scala — 4 commits
• project/plugins.sbt — 1 commit

• fix: Merge pull request #1559 from UdashFramework/fix/rest-servlet-disconnect-flakes
• change: Document aborts missed during the dispatch and pin the unclosed response
• change: Keep a failing close of a broken streamed response off the uncaught reporter
• change: Keep a stream failing after a disconnect off the uncaught reporter too
• change: Keep a streamed write failing after a disconnect off the uncaught reporter
• change: Limit RestServlet disconnect handling to actual disconnects
• change: Log a streamed response failing after a cancellation instead of dropping it
• change: Merge branch 'master' into update/selenium-java-4.49.0
• change: Merge pull request #1538 from scala-steward/update/monix-3.5.0
• change: Merge pull request #1545 from pkurcx/rest-cancel-on-client-disconnect
• change: Merge pull request #1547 from scala-steward/update/selenium-java-4.49.0
• change: Merge pull request #1548 from scala-steward/update/sbt-native-packager-1.12.0
• change: Merge pull request #1551 from scala-steward/update/moment-2.31.0
• change: Merge pull request #1553 from scala-steward/update/webdrivermanager-6.4.0
• change: Merge pull request #1555 from scala-steward/update/selenium-java-4.50.0
• change: Merge pull request #1557 from scala-steward/update/commons-core-2.30.0
• change: Tell client-gone write failures apart from handler failures in RestServlet
• change: Update commons-analyzer, commons-core, ... to 2.30.0
• change: Update moment to 2.31.0
• change: Update sbt-native-packager to 1.12.0
• …and 3 more

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

UdashFramework/udash-core 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.