API Reference Raxol v0.3.0
View SourceModules
Raxol is a feature-rich terminal UI framework for Elixir.
Content generation capabilities for Raxol applications.
Runtime AI features for intelligent performance optimization.
The Accounts context. Manages user accounts and registration. (Currently uses an in-memory Agent for storage)
Handles accessibility concerns for the Animation Framework, specifically adapting animations for reduced motion preferences.
Delegates animation API calls to Raxol.Animation.Framework for test and compatibility purposes.
Provides standard easing functions for animations.
Coordinates the lifecycle of animations within Raxol.
Gesture-driven interactions for Raxol animations.
Provides interpolation functions for different data types.
Force field implementation for physics simulations.
Physics engine for Raxol animations.
3D vector implementation for physics simulations.
Manages the state for the Raxol Animation Framework.
Authentication module for handling user authentication and authorization.
Permission schema for role-based access control.
Plug for handling authentication and authorization.
Role schema for role-based access control.
User schema for authentication and authorization.
Performance benchmarking and validation tools for Raxol.
Animation performance benchmark functions for Raxol.
Event handling performance benchmark functions for Raxol.
Memory usage performance benchmark functions for Raxol.
Rendering performance benchmark functions for Raxol.
Reporting functions (saving, printing) for Raxol performance benchmarks.
Validation functions for Raxol performance benchmarks.
Performance benchmarking tool for visualization components. Provides tools to measure rendering time, memory usage, and optimization effectiveness for different data sizes and visualization types.
A realistic benchmark tool for visualization components with progressive data sizes. Tests the performance impact of our optimizations on various dataset sizes.
A simplified benchmark tool for visualization components, without external dependencies. This is designed for direct testing during development without requiring the full application.
CLI command for managing Raxol updates.
Handles clipboard operations across different platforms. Provides a unified interface for copy/paste functionality.
Cloud integration system for Raxol applications.
Configuration management for Raxol cloud integrations.
Core functionality for Raxol cloud integrations.
Edge computing support for Raxol applications.
Cloud integration utilities for Raxol applications.
Cloud monitoring system for Raxol applications.
Centralized state management for Raxol cloud components.
Provides base functionality and utilities for Raxol components.
A customizable button component.
Renders a block of code with syntax highlighting.
A component responsible for rendering a grid-based dashboard layout. Manages widget placement, drag/drop, and resizing.
State for the Dashboard component.
Calculates layout bounds for widgets within a grid configuration. This module provides functions to determine the position and size of widgets based on a grid layout definition (columns, rows, gaps).
Handles saving and loading dashboard widget layouts to disk.
A container component for dashboard widgets. Provides a frame, title bar (optional), and potentially drag/resize handles. Renders the actual widget content passed to it.
A dashboard widget that displays a chart using Raxol.Components.Visualization.Chart. This module is responsible for holding the chart's state (data, config) and providing a data structure for rendering, rather than rendering directly.
A dashboard widget that displays simple text information.
A dashboard widget that displays a treemap using Raxol.Components.Visualization.TreeMap. This module is responsible for holding the treemap's state (data, config) and providing a data structure for rendering, rather than rendering directly.
Handles drawing the focus ring around focused components.
Displays contextual hints and keyboard shortcuts.
Helper for clipboard operations (copy/cut/paste) in MultiLineInput.
A simple single-line text input component.
A text input component for single-line text entry.
Handles text manipulation operations for the TextInput component. This includes inserting, deleting, and pasting text.
Handles rendering logic for the TextInput component. This includes display value formatting, style management, and visual feedback.
Handles cursor and text selection operations for the TextInput component. This includes cursor movement, text selection, and selection clearing.
Handles input validation for the TextInput component. This includes length validation, pattern matching, and error message generation.
Utility functions for text wrapping.
Renders Markdown text into Raxol elements or raw HTML.
A modal component for displaying overlay dialogs like alerts, prompts, confirmations, and forms.
Provides components for displaying progress, like progress bars and spinners.
A component to display a progress bar.
A spinner component that provides animated loading indicators.
A dropdown component that allows selecting one option from a list.
A component for displaying a selectable list of items.
A tab bar component for Raxol.
Table component for displaying and interacting with tabular data.
A terminal component that emulates a standard terminal within the UI.
Terminal emulator component wrapping the core emulator logic.
A text input component with editing capabilities.
Accessibility module for Raxol terminal UI applications.
Handles screen reader announcements and announcement queue management.
Defines the behaviour for accessibility services. This behaviour outlines the contract for modules that provide accessibility functionality such as screen reader announcements, feature toggles (high contrast, reduced motion, large text), and preference management related to accessibility.
Handles accessibility-related events and notifications.
Legacy functions for backwards compatibility. These functions are deprecated and will be removed in a future version.
Handles accessibility metadata for UI elements and component styles.
Mock implementation for Raxol.Core.Accessibility.
Manages accessibility preferences and settings.
Manages the integration between accessibility settings and the active theme.
Core color system for Raxol.
Defines the structure for events in the Raxol system, providing a standardized format for key presses, mouse actions, and other UI events that components need to process.
Event manager for handling and dispatching events in Raxol applications.
Provides helpers for managing event subscriptions.
Converts rrex_termbox v2.0.1 NIF events to Raxol.Core.Events.Event structs.
Focus management system for Raxol terminal UI applications.
Defines the behaviour for focus management services.
Internationalization framework for Raxol terminal UI applications.
Provides functions for generating unique identifiers.
Keyboard navigation handler for Raxol terminal UI applications.
Keyboard shortcuts manager for Raxol applications.
Behaviour for the KeyboardShortcuts module. This allows for mocking the KeyboardShortcuts module in tests.
Handles AI-based analysis of performance metrics and generates optimization recommendations. This module integrates with an AI agent to provide deep insights and actionable suggestions.
Analyzes performance metrics and generates insights for AI analysis.
Detects UI jank by analyzing frame timing.
Collects and calculates performance metrics.
Performance monitoring system for Raxol applications.
Core plugin providing clipboard read/write commands. Delegates to the configured system clipboard implementation.
Core plugin responsible for handling notifications (:notify). Relies on an implementation of Raxol.System.Interaction for OS interactions.
Handles persistence (loading/saving) of user preferences to a file.
Handles storage and retrieval of user preferences.
Manages terminal buffer rendering with double buffering and damage tracking.
Provides comprehensive color support for terminal rendering.
Defines the core element structure for the rendering system.
Manages the rendering system for Raxol applications.
Main facade module for the Raxol view system. Provides a unified interface for creating and managing views.
Handles box layout functionality for the Raxol view system. Provides box model layout with content, padding, border, and margin.
Handles scrollable views for the Raxol view system. Provides viewport management, scrollbar rendering, and content scrolling.
Handles text rendering for the Raxol view system. Provides text styling, wrapping, and alignment functionality.
Handles flex layout functionality for the Raxol view system. Provides row and column layouts with various alignment and justification options.
Handles grid-based layouts for the Raxol view system. Provides functionality for creating and managing grid layouts with customizable columns and rows.
Handles border rendering for the Raxol view system. Provides various border styles and rendering functionality.
Type definitions for the Raxol view system.
Provides utility functions for common view operations in the Raxol view system.
Chart view component for data visualization.
Table view component for displaying tabular data.
Defines the behaviour for Raxol applications following The Elm Architecture (TEA).
Provides a way to handle side effects in a pure functional way.
Manages component lifecycle and state in the Raxol runtime system.
Simple logging wrapper for the runtime.
Behaviour for implementing custom event sources for subscriptions.
Handles conversion between different event formats in the Raxol system.
Manages the application state (model) and dispatches events to the application's
update/2
function. It also handles commands returned by update/2
.
Defines the behaviour for the Event Dispatcher GenServer.
Manages event handlers registration and execution in the Raxol system.
Handles keyboard event processing in the Raxol system.
Manages the application lifecycle, including startup, shutdown, and terminal interaction.
Public API for Raxol plugins to interact with the core system.
Handles command execution and management for plugins. This module is responsible for
Handles plugin command registration and dispatch for the Plugin Manager.
Defines the behaviour for plugin command management.
Manages command registration and execution for plugins.
Manages plugin dependencies and dependency resolution. Provides sophisticated version constraint handling, efficient cycle detection, and detailed dependency chain reporting.
Defines the behaviour for plugin dependency management.
Core module for managing plugin dependencies and dependency resolution. Provides the main public API for dependency checking and load order resolution.
Handles dependency graph building and cycle detection for plugin dependencies. Provides functionality for building dependency graphs and analyzing dependency chains.
Handles load order resolution for plugin dependencies using Tarjan's algorithm. Provides efficient cycle detection and topological sorting of dependencies.
Handles version parsing and constraint checking for plugin dependencies. Provides sophisticated version constraint handling with support for complex requirements.
Test helper functions for DependencyManager tests.
Handles plugin discovery and initialization. This module is responsible for
Handles event filtering for plugins. This module is responsible for
Handles file watching functionality for plugins.
Defines the behaviour for file watching functionality in the plugin system.
Handles cleanup of file watching resources.
Core functionality for file watching in plugins. Handles basic setup and state management.
Handles file system events and debouncing for plugin reloading.
Handles plugin reloading functionality.
Helper functions for plugin lifecycle management.
Defines the behaviour for plugin lifecycle management.
Handles plugin lifecycle operations including enabling, disabling, and reloading plugins. This module is responsible for
Handles loading plugin code, metadata, and discovery.
Implements the Raxol.Core.Runtime.Plugins.LoaderBehaviour
.
Defines the behaviour for plugin loading functionality.
Manages the loading, initialization, and lifecycle of plugins in the Raxol runtime.
Defines the behaviour for plugin management functionality. This is used for mocking in tests.
Defines the behaviour for Raxol plugins.
Defines the behaviour for plugin command dispatching.
Defines the behaviour for plugin command handling.
Defines the behaviour for plugin command registration and dispatch.
Defines the behaviour for plugin command registration.
Defines the behaviour for plugin event filtering.
Defines the behaviour for plugins that provide metadata like ID, version, and dependencies.
Defines the behaviour for plugin metadata providers.
Handles plugin reloading operations. This module is responsible for
Defines the behaviour for plugin reloading functionality.
Placeholder for the plugin registry. Manages information about loaded plugins.
Manages plugin state and state transitions.
Defines the behaviour for plugin state management.
Implements timer management functionality for plugins.
Defines the behaviour for plugin timer management.
Provides a screen buffer implementation for efficient rendering in Raxol applications.
Provides the core rendering functionality for Raxol applications.
Behaviour for Rendering.Engine, used for mocking.
Manages the rendering schedule based on frame rate.
Provides a way to subscribe to recurring updates and external events.
Supervises the core runtime processes of a Raxol application.
Defines a behaviour for interacting with the operating system, allowing for mocking.
Handles OSC 4 (Color Palette Set/Query) commands.
Minimal state struct for color palette OSC handler tests.
User experience refinement module for the Raxol terminal UI.
Manages user preferences for the Raxol application.
Defines the behaviour for UserPreferences services.
Internal state for the UserPreferences GenServer.
Provides a safe interface for database operations.
Manages database connections and provides retry logic for Postgres errors.
Visual component catalog for Raxol documentation.
Interactive tutorial system for Raxol documentation.
Handles loading and parsing of tutorials from markdown files.
Defines the core data structures for the interactive tutorial system.
Represents a single step in a tutorial.
Represents a complete tutorial with multiple steps.
Handles navigation and progress tracking for tutorials.
Handles rendering of tutorial content and interactive elements.
Manages the state of the interactive tutorial system.
Handles validation of tutorial exercises and user input.
UI Component for displaying interactive tutorials.
A dynamic supervisor for dynamically starting Raxol application processes.
Showcase for the enhanced FocusRing component with various styling options.
Showcase for the enhanced SelectList component with its various features.
Handles collection and management of system metrics.
Collects and stores performance metrics for the Raxol event system. Works in conjunction with the Visualizer module to provide insights into system performance.
Provides visualization capabilities for Raxol performance metrics. Uses Contex to generate charts and graphs for various performance indicators.
Defines the behavior for Raxol plugins. Plugins can extend the terminal's functionality by implementing this behavior.
Handles the processing of rendered cells, allowing plugins to modify or replace them. Especially targets placeholder cells generated by the rendering pipeline.
Plugin for clipboard operations in Raxol.
Handles dispatching various events (input, resize, mouse, etc.) to plugins.
Plugin that detects URLs in terminal output and makes them clickable.
Plugin that enables displaying images in the terminal using the iTerm2 image protocol. Supports various image formats and provides options for image display.
Handles the lifecycle management of Raxol plugins.
Handles cell processing functionality. Provides functions for processing and transforming cells through plugins.
Core functionality for the plugin manager. Handles basic plugin management operations and state.
Handles plugin event processing. Provides functions for processing various types of events through plugins.
Handles plugin hook execution. Provides functions for running various plugin hooks and collecting their results.
Handles plugin state management and updates. Provides functions for updating plugin state and managing plugin lifecycle states.
Defines the behavior for Raxol terminal emulator plugins. Plugins can extend the terminal's functionality by implementing this behavior.
Handles persistence of plugin configurations. Stores and loads plugin configurations from disk.
Manages plugins for the Raxol terminal emulator. Handles plugin loading, lifecycle management, and event dispatching.
Plugin for text search functionality.
Plugin that manages terminal themes and color schemes. Allows users to apply predefined themes or create custom color schemes.
Handles rendering logic for chart visualizations within the VisualizationPlugin.
Utility functions for drawing basic shapes and text onto a cell grid. Used by visualization renderers.
Handles rendering logic for image placeholders within the VisualizationPlugin. Currently provides a text placeholder, but intended for protocols like sixel or kitty.
Handles rendering logic for treemap visualizations within the VisualizationPlugin. Uses a squarified layout algorithm.
Plugin responsible for rendering visualization components like charts and treemaps. It receives data structures from the view rendering pipeline and outputs actual terminal cells.
Handles layout calculations for UI elements.
The main supervisor for the Raxol application runtime. Manages core processes like Dispatcher, PluginManager, etc.
Session management module for handling terminal sessions.
Defines style properties for terminal UI elements.
Defines border properties for terminal UI elements.
Provides utilities for color accessibility, focusing on WCAG contrast.
Detects terminal capabilities and adapts color schemes accordingly.
Provides advanced color handling capabilities for the terminal.
Core color representation and manipulation module.
Color format conversion utilities.
Creates and manages color gradients for terminal applications.
Provides functions for HSL color space conversions and adjustments.
Provides functions for generating color harmonies based on a base color.
Provides hot-reloading capabilities for color themes.
Handles persistence of color themes and user preferences.
Core color system for the Raxol terminal emulator.
Shared color utilities for the Raxol color system.
Defines layout properties for terminal UI elements.
Provides consolidated access to the system clipboard across different operating systems.
Behaviour for clipboard operations. Allows mocking in tests.
Handles delta updates for the Raxol terminal emulator.
Behaviour for a system adapter used by DeltaUpdater.
A behaviour for abstracting system environment interactions.
Concrete implementation of EnvironmentAdapterBehaviour using Elixir's System module.
Behaviour for abstracting system interactions like running commands, finding executables, and getting OS type. Allows for easier testing.
Concrete implementation of the System.Interaction behaviour using standard Elixir/Erlang functions.
Platform-specific functionality and detection for Raxol.
Terminal-specific platform features and compatibility checks.
Provides version management and self-update functionality for Raxol.
ANSI escape sequence handling.
Manages character set switching and translation for the terminal emulator. Supports G0, G1, G2, G3 character sets and their switching operations.
Handles character set control sequences and state changes.
Manages character set state and operations.
Handles character set translations and mappings.
Provides character translation tables for different character sets. Maps characters between different character sets according to ANSI standards.
Handles terminal state queries and device status reports. This includes cursor position reports, device status reports, and terminal identification queries.
ANSI escape sequence generation module.
Handles mouse event reporting for the terminal emulator. Supports various mouse reporting modes including
ANSI escape sequence parser module.
ANSI sequence processor module.
Handles parsing of SGR (Select Graphic Rendition) ANSI escape sequences. Translates SGR codes into updates on a TextFormatting style map.
Helper module for parsing ANSI escape sequences.
ANSI Color Sequence Handler.
ANSI Cursor Sequence Handler.
ANSI Terminal Modes Sequence Handler.
Handles Sixel graphics for the terminal emulator. Supports
Handles Sixel color palette management.
Handles the parsing logic for Sixel graphics data streams within a DCS sequence.
Provides a mapping from Sixel characters to their 6-bit pixel patterns.
Handles rendering Sixel graphics data from a pixel buffer.
Manages terminal state for the terminal emulator. Handles saving and restoring terminal state, including cursor position, attributes, character sets, and screen modes.
Behaviour for managing terminal state saving and restoring.
Handles advanced text formatting features for the terminal emulator. This includes double-width and double-height characters, as well as other advanced text attributes and colors.
Handles window manipulation sequences for the terminal emulator. Supports various window operations including
Handles character insertion and deletion within the Raxol.Terminal.ScreenBuffer lines.
Manages damage tracking for terminal buffers.
Handles erasing parts of the Raxol.Terminal.ScreenBuffer. Includes functions for erasing lines, screen regions, and characters.
Handles insertion and deletion of lines within the Raxol.Terminal.ScreenBuffer.
Manages terminal buffers and their operations. Coordinates between different buffer-related modules.
Handles buffer operations and synchronization for the terminal. Provides functionality for buffer manipulation, double buffering, and synchronization.
Handles cursor management for the terminal buffer. Provides functionality for cursor position tracking and movement.
Handles damage tracking for the terminal buffer. Provides functionality for tracking and managing damaged regions.
Handles memory management for the terminal buffer. Provides functionality for tracking memory usage and enforcing limits.
Handles scrollback buffer management for the terminal. Provides functionality for managing scrollback history and operations.
Handles state management for the terminal buffer manager. Provides functionality for initializing and managing buffer state.
Handles calculation and checking of terminal buffer memory usage.
Provides functions for manipulating the Raxol.Terminal.ScreenBuffer grid and state. Includes writing, clearing, deleting, inserting, resizing, and other operations.
Terminal scroll buffer module.
Manages the scrollback buffer lines.
Handles scrolling operations (up and down) within the Raxol.Terminal.ScreenBuffer, considering scroll regions.
Handles text selection within the Raxol.Terminal.ScreenBuffer.
Handles state management and accessors for the Raxol.Terminal.ScreenBuffer. Includes resizing, getting dimensions, accessing cells/lines, managing scroll regions, and getting content.
Handles calculating differences and applying updates to the Raxol.Terminal.ScreenBuffer.
Handles writing characters and strings to the Raxol.Terminal.ScreenBuffer. Responsible for character width, bidirectional text segmentation, and cell creation.
Terminal character cell module.
Handles wide character and bidirectional text support for the terminal emulator.
Manages terminal command history and processing, including command buffer, history, and command execution.
DEPRECATED: Handles the execution of parsed terminal commands.
Handles buffer manipulation related CSI commands.
Handles the execution logic for specific CSI commands.
Handles cursor movement related CSI commands.
Handles the execution logic for specific DCS commands.
Handles device status and attribute related CSI commands.
Handles editor operations for the terminal buffer.
Handles erase related CSI commands.
Executes parsed terminal commands (CSI, OSC, DCS).
Manages command history for the terminal emulator.
Handles mode setting and resetting related CSI commands.
Handles the execution logic for specific OSC commands.
Provides parameter validation functions for CSI command handlers.
Handles parsing of command parameters in terminal sequences.
Handles screen manipulation commands in the terminal.
Handles window manipulation related CSI commands. These commands are used to control the terminal window's position, size, and state.
Terminal configuration system.
Manages caching for terminal animations.
Terminal configuration application.
Terminal capability detection and management.
Default terminal configuration values.
Defines the behaviour for terminal environment configuration.
Handles loading and saving terminal configuration.
Terminal configuration profile management.
Schema definitions for terminal configuration.
Utility functions for handling terminal configuration maps.
Validation logic for terminal configuration.
Manages the core Raxol terminal configuration struct.
Re-exports constants from ExTermbox NIF v2.0.1 for use within Raxol.
Handles C0 control codes and simple ESC sequences.
Core state struct for the terminal emulator. This struct holds the main state fields used by the emulator state management functions.
Manages cursor state and operations.
Handles cursor movement and positioning for the terminal emulator.
Handles cursor style and visibility control for the terminal emulator.
ASCII art rendering system for the Raxol terminal emulator.
Handles raw terminal input/output and event generation.
Behaviour for Terminal.Driver, used for mocking.
Manages the state of the terminal emulator, including screen buffer, cursor position, attributes, and modes.
Handles screen buffer management for the terminal emulator. Provides functions for buffer operations, scroll region handling, and buffer switching.
Core functionality for the terminal emulator. Handles basic initialization, state management, and fundamental operations.
Handles cursor management for the terminal emulator. Provides functions for cursor position, style, movement, and state management.
Handles input processing for the terminal emulator. Provides functions for key event handling, command history, and input parsing.
Handles output processing for the terminal emulator. Provides functions for output buffering, processing, and formatting.
Handles state management for the terminal emulator. Provides functions for managing terminal state, modes, and character sets.
Handles text styling and formatting for the terminal emulator. Provides functions for managing character attributes, colors, and text formatting.
Handles window management for the terminal emulator. Provides functions for window state, manipulation, and properties.
Defines the behaviour for the core Terminal Emulator.
Handles parsing of ANSI escape sequences and other control sequences.
Terminal input module.
Handles input buffering for the terminal emulator. Provides functionality for storing, retrieving, and manipulating input data.
Utility functions for Raxol.Terminal.Input.InputBuffer.
Handles input processing for the terminal emulator, including
Manages input handling for the terminal emulator, including
Handles special key combinations and their escape sequences.
Defines shared types for the Raxol terminal input subsystem.
Handles parsed terminal input events (printable characters, control codes, escape sequences) and updates the Emulator state accordingly.
Coordinates terminal integration components and provides a unified interface for terminal operations.
Handles buffer and cursor management for the terminal.
Handles configuration management for the terminal integration.
Handles input processing and command history management for the terminal.
Handles terminal output rendering and display management.
Manages the state of the integrated terminal system.
Terminal manager module.
Monitors and manages memory usage for terminal processes.
Manages terminal modes (DEC Private Modes, Standard Modes) and their effects.
Handles terminal modes and state transitions for the terminal emulator.
Parses raw byte streams into terminal events and commands. Handles escape sequences (CSI, OSC, DCS, etc.) and plain text.
Manages parser state transitions and state-specific functionality for the terminal emulator. This module provides a clean interface for managing the parser's state machine and delegating to appropriate state handlers.
Handles the :csi_entry state of the terminal parser.
Handles the :csi_intermediate state of the terminal parser.
Handles the :csi_param state of the terminal parser.
Handles the :dcs_entry state of the terminal parser.
Handles the :dcs_passthrough_maybe_st state of the terminal parser.
Handles the :dcs_passthrough state of the terminal parser.
Handles the :designate_charset state of the terminal parser.
Handles the :escape state of the terminal parser.
Handles the :ground state of the terminal parser. Processes plain text and transitions to other states on control codes/escape sequences.
Handles the :osc_string_maybe_st state of the terminal parser.
Handles the :osc_string state of the terminal parser.
Terminal registry module.
Terminal renderer module.
Manages the terminal's screen buffer state (grid, scrollback, selection). Delegates operations to specialized modules in Raxol.Terminal.Buffer.*
Behaviour for terminal screen buffer operations.
Terminal session module.
Manages terminal state including modes, character sets, and state stack.
Manages text styling and formatting for the terminal emulator. This module provides a clean interface for managing text styles, colors, and attributes.
Supervisor for terminal-related processes.
Utility functions for terminal operations, providing cross-platform and consistent handling of terminal capabilities and dimensions.
Alias module for Raxol.Terminal.ANSI.TextFormatting. This module re-exports the functionality from ANSI.TextFormatting to maintain compatibility.
Common assertion helpers for Raxol tests. Provides standardized assertions for components, events, and state.
Canonical test helpers for clipboard-related tests in Raxol. Provides utilities for state creation, clipboard command assertions, and Mox setup.
Helpers for testing event handling in Raxol components. Provides utilities for simulating and verifying events.
Provides utilities for testing component interactions and system integration.
Provides custom assertions for integration testing of Raxol components.
Mock implementation of rrex_termbox v2.0.1 for testing environments.
Provides utilities for performance testing of Raxol components.
Provides assertions for performance testing of Raxol components.
Provides utilities for performance testing and benchmarking in Raxol.
DEPRECATED: Use Raxol.Test.PerformanceHelper instead. This module is deprecated and will be removed in a future release. Please update your tests to use Raxol.Test.PerformanceHelper.
Provides common test utilities and setup functions for Raxol tests.
Provides utilities for unit testing Raxol components and modules.
Provides custom assertions for testing Raxol components.
Provides utilities for visual testing of Raxol components.
Provides custom assertions for visual testing of Raxol components.
Provides pattern matching helpers for visual testing of Raxol components.
Defines the behavior for UI components in the Raxol system.
Provides component lifecycle hooks and management for UI components.
A progress bar component for displaying completion status.
A component for displaying tabular data with sorting, filtering, and pagination.
Button component for interactive UI elements.
Checkbox component for toggling boolean values.
A multi-line input component for text editing, supporting line wrapping, scrolling, selection, and accessibility.
UI adapter for MultiLineInput's ClipboardHelper. Delegates to the implementation in Raxol.Components.Input.MultiLineInput.ClipboardHelper.
Handles key and mouse events for MultiLineInput, translating them into update messages.
Helper functions for cursor navigation and text selection in MultiLineInput.
UI adapter for MultiLineInput's RenderHelper. Delegates to the implementation in Raxol.Components.Input.MultiLineInput.RenderHelper.
Helper functions for text and line manipulation in MultiLineInput.
A component that allows users to select an option from a list.
Handles keyboard navigation functionality for the SelectList component.
Handles pagination functionality for the SelectList component.
Handles rendering functionality for the SelectList component.
Handles search and filtering functionality for the SelectList component.
Handles selection functionality for the SelectList component.
A text field component for single-line text input.
A text input component for capturing user text input.
Handles layout calculations for container elements like rows and columns.
Core layout engine that translates the logical view structure into absolute positions.
Handles layout calculations for grid UI elements.
Handles layout calculations for panel UI elements.
Handles measurement and positioning logic for Table elements within the LayoutEngine.
Translates a positioned element tree into a flat list of renderable cells.
Manages the rendering pipeline for the UI.
A terminal UI rendering module for Raxol.
Color management utilities for theme handling.
A component for selecting and applying themes.
Theme management for Raxol UI components.
Defines the behaviour for Theme services.
Provides component functions for Raxol views.
Basic UI elements for Raxol views.
Provides layout functions for Raxol views.
Manages authentication state and operations for the Raxol application.
Manages web sessions and terminal connections for the Raxol application.
Handles session cleanup for Raxol applications.
Manages web sessions for Raxol applications.
Handles session monitoring for Raxol applications.
Handles session recovery for Raxol applications.
Database schema for session storage.
Handles session storage and retrieval for Raxol applications.
Supervisor for web-related processes.
The entrypoint for defining your web interface, such as controllers, components, channels, and so on.
Provides core UI components for the Raxol web interface.
A module providing Internationalization with a gettext-based API.
View module for pages served by PageController.
WebSocket channel for real-time terminal communication.
LiveView component for the terminal interface.
Provides authentication plugs and helpers.
Handles user registration.
Handles user session management (login/logout).
Mix Tasks
Runs visualization performance benchmarks.