API Reference Raxol v#0.5.0
View SourceModules
Defines the behaviour for file system operations. This is used for mocking in tests.
Default implementation of File.Behaviour for testing.
Defines the behaviour for file system watching functionality. This is used for mocking in tests.
A simple mock Form component for testing button interactions.
Implements a JSON String Parser for Bitstring values
Implements a JSON Unicode Parser for Bitstring values
Raxol is a feature-rich terminal UI framework for Elixir.
Content generation capabilities for Raxol applications.
Runtime AI features for intelligent performance optimization.
Test helpers for accessibility-related assertions and simulation in Raxol. Provides assertion helpers for screen reader announcements, contrast, keyboard navigation, and focus management.
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.
Benchmarking utilities for Raxol.
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.
Accessibility module for Raxol terminal UI applications.
Handles screen reader announcements and announcement queue management.
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 of the accessibility module for testing.
Manages accessibility preferences and settings.
Manages the integration between accessibility settings and the active theme.
Behaviour for clipboard operations.
Core color system for Raxol.
Utility functions for component-related logic shared across Raxol modules.
Configuration manager for the Raxol Terminal Emulator. Provides a unified interface for managing all configuration options, including loading, validation, and runtime updates.
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.
Metric aggregation system for the Raxol metrics.
Alert management system for the Raxol metrics.
Cloud integration for the Raxol metrics system.
Configuration management for the Raxol metrics system.
Manages unified metrics collection across the application.
Visualization system for the Raxol metrics.
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.
Provides clipboard read/write commands and delegates to a configured system clipboard implementation.
Defines the behaviour for clipboard plugin operations.
Core plugin responsible for handling notifications (:notify). Relies on an implementation of Raxol.System.Interaction for OS interactions.
Manages user preferences including accessibility settings like reduced motion.
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.
Provides view-related functionality for rendering UI components.
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.
Debug logging functionality for the Raxol runtime.
Behaviour for implementing custom event sources for subscriptions.
A test implementation of an event source for testing purposes.
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.
Standardized logging helpers for error and warning messages with context and stacktraces.
Public API for Raxol plugins to interact with the core system.
This module is responsible for processing cells in the Raxol runtime.
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, ensuring that plugins are loaded in the correct order and that their dependencies are met.
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
Manages file watching operations 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.
Behaviour defining the interface for file watching operations.
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
Manages plugin loading operations.
Behaviour defining the interface for plugin loading operations.
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.
Plugin registry using GenServer for state management. Manages information about loaded plugins and their metadata.
Defines the state struct for the plugin manager.
Manages plugin state and state transitions.
Defines the behaviour for plugin state management.
Manages timers and scheduling for plugin operations.
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.
Represents the core state of a terminal instance.
Handles text processing and formatting for UI elements.
User experience refinement module for the Raxol terminal UI.
Manages user preferences for the terminal emulator.
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 interactive tutorial content.
Manages the state of the interactive tutorial system.
Handles validation of tutorial exercises and user input.
Handles rendering for documentation.
Interactive tutorial viewer component.
A dynamic supervisor for dynamically starting Raxol application processes.
A demo showcasing integrated accessibility features.
Showcase for the enhanced FocusRing component with various styling options.
Showcase for the enhanced SelectList component with its various features.
Test helpers for internationalization testing that integrate with accessibility 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.
Provides utilities for plugin dependency and API compatibility checks.
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 visualization within the VisualizationPlugin. Supports both sixel and kitty protocols for terminal image rendering.
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.
Protocols module for managing protocols.
Protocol module for handling protocol-related functionality.
Handles layout calculations for UI elements.
Default renderer module for the Raxol pipeline. Delegates to the main UI rendering process.
The main supervisor for the Raxol application runtime. Manages core processes like Dispatcher, Plugin system, etc.
Defines the structure for a sequence of terminal commands.
Handles the execution of sequences of terminal commands.
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.
Handles layout styling for Raxol components.
Provides consolidated access to the system clipboard across different operating systems.
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.
This module serves as a documentation reference for the ANSI terminal functionality.
Provides benchmarking capabilities for the ANSI handling system. Measures performance of parsing and processing ANSI sequences.
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.
Provides ANSI color functionality for terminal output. Handles color parsing, setting, and management for terminal text.
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 extended ANSI sequences and provides improved integration with the screen buffer. This module adds support for
Provides monitoring capabilities for the ANSI handling system. Tracks performance metrics, errors, and sequence statistics.
Handles mouse event reporting for the terminal emulator. Supports various mouse reporting modes including
Handles mouse tracking and focus tracking for the terminal. Supports various mouse tracking modes and focus tracking events.
Provides comprehensive parsing for ANSI escape sequences. Determines the type of sequence and extracts its parameters.
Processes ANSI escape sequences for terminal control.
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.
Sixel graphics support for terminal rendering.
Behaviour for Sixel graphics support.
Handles Sixel color palette management.
Handles the parsing logic for Sixel graphics data streams within a DCS sequence.
Represents the state during the parsing of a Sixel graphics data stream. Tracks position, color, palette, and pixel buffer information.
Provides a mapping from Sixel characters to their 6-bit pixel patterns.
Handles rendering Sixel graphics data from a pixel buffer.
A state machine for parsing ANSI escape sequences. This module provides a more efficient alternative to regex-based parsing.
Manages terminal state operations for ANSI escape sequences.
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.
Defines the behaviour for text formatting in the terminal. This includes handling text attributes, colors, and special text modes.
Handles window events for terminal control. Supports window close, minimize, maximize, restore, and other window events.
Handles window manipulation sequences for terminal control. Supports window resizing, positioning, and state management.
Manages the terminal buffer state and operations.
Manages caching for the terminal buffer system. Provides efficient caching mechanisms for frequently accessed buffer regions.
Manages terminal cell operations and attributes.
Manages terminal character editing operations.
Handles character-based operations in the terminal buffer.
Manages character set state and operations for the screen buffer. This module handles character set designations, G-sets, and single shifts.
Handles buffer commands for the unified buffer manager.
Common buffer operations shared between different buffer-related modules. This module provides utility functions for buffer manipulation that are used by multiple modules to avoid code duplication.
Handles content operations for the screen buffer. This module provides functions for writing and reading content from the buffer, including character and string operations.
Manages cursor state and operations for the screen buffer. This module handles cursor position, visibility, style, and blink state.
Manages damage tracking for terminal buffers.
Enhanced buffer manager with advanced features for improved performance.
Provides screen clearing operations for the screen buffer. This module handles operations like clearing the screen, lines, and regions.
Manages text formatting state and operations for the screen buffer. This module handles text attributes, colors, and style management.
Handles initialization and validation of screen buffers. This module provides functions for creating new screen buffers and validating their dimensions and properties.
Provides functionality for line editing operations in the terminal buffer.
Provides line-level operations for the screen buffer. This module handles operations like inserting, deleting, and manipulating lines.
Behaviour for terminal buffer line operations. This module defines the callbacks required for manipulating lines in the screen buffer.
Manages terminal buffer operations and state.
Behaviour for terminal buffer management.
Handles buffer operations and synchronization for the terminal. Provides functionality for buffer manipulation, double buffering, and synchronization.
Implementation of buffer operations for the terminal. This module contains the actual implementation of buffer operations that are used by the public Buffer interface.
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.
Defines the state structure and operations for the buffer manager. This module handles the core state management for the terminal buffer, including active buffer, back buffer, scrollback, damage tracking, and memory management.
Handles calculation and checking of terminal buffer memory usage.
Handles buffer operations for the terminal, including resizing, scrolling, and cursor movement.
Defines the behaviour for terminal buffer operations.
Delegates buffer operations to Raxol.Terminal.Buffer.Operations. This module exists to resolve undefined function errors for BufferOps.*
Handles buffer state querying operations. This module provides functions for querying the state of the screen buffer, including dimensions, content, and selection state.
Behaviour for terminal buffer querying operations. This module defines the callbacks required for querying the state of the screen buffer, including dimensions, content, and selection state.
Terminal scroll buffer module.
Handles scroll region operations for the screen buffer. This module manages the scroll region boundaries and provides functions for scrolling content within the defined region.
Behaviour for terminal scroll region buffer.
Handles scrollback buffer operations for the screen buffer. This module manages the history of lines that have scrolled off the screen, including adding, retrieving, and clearing scrollback content.
Behaviour for terminal scrollback buffer.
Manages scrollback buffer for the terminal emulator.
Handles scrolling operations for the terminal buffer.
Manages text selection operations for the terminal. This module handles all selection-related operations including
Behaviour for terminal selection buffer.
Handles state management and accessors for the Raxol.Terminal.ScreenBuffer. Includes resizing, getting dimensions, accessing cells/lines, managing scroll regions, and getting content.
Manages terminal text formatting operations.
Unified buffer management system for the Raxol terminal emulator. This module combines and enhances the functionality of the previous buffer managers, providing improved memory management, caching, and performance metrics.
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.
Manages buffer operations and tab stops for the terminal.
Helper functions for cache eviction strategies. Provides shared implementations for LRU, LFU, and FIFO eviction policies.
Unified caching system for the Raxol terminal emulator. This module provides a centralized caching mechanism that consolidates all caching operations across the terminal system, including
Unified caching system for the Raxol terminal emulator. This module provides a centralized caching mechanism for all terminal operations, including buffer operations, animations, scroll operations, and edge computing.
Manages terminal capabilities including detection, negotiation, and caching.
Defines types and structures for terminal capabilities management.
Terminal character cell module.
Handles wide character and bidirectional text support for the terminal emulator.
Manages character sets for the terminal emulator.
Manages terminal character sets and encoding operations.
Provides character mapping functions for different character sets.
Provides operations for managing character sets and their state.
Defines types used across the charset modules.
Manages the terminal character sets.
Provides a high-level interface for clipboard operations.
Handles clipboard content formatting and filtering.
Manages clipboard history for the terminal.
Manages clipboard operations for the terminal, including copying and pasting text.
Manages clipboard content storage and retrieval.
Handles clipboard synchronization between different terminal instances.
Defines the behaviour for clipboard operations in the terminal.
Manages terminal colors and color operations.
Manages terminal colors and color-related operations.
Manages terminal command state, history, and execution.
DEPRECATED: Handles the execution of parsed terminal commands.
Handles buffer manipulation commands.
Handlers for CSI (Control Sequence Introducer) commands.
Handlers for basic CSI commands.
Handles CSI cursor control sequences.
Handlers for device-related CSI commands.
Main coordinator module for CSI (Control Sequence Introducer) commands. Routes commands to the appropriate handler modules.
Handles Select Graphic Rendition (SGR) commands.
Handles screen-related CSI commands.
Handles cursor movement related CSI commands.
Handles Device Control String (DCS) commands for the terminal emulator.
Handles device status and attribute related CSI commands.
Handles editor-related terminal commands.
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 Operating System Command (OSC) sequences.
Handles clipboard-related OSC commands.
Handles color-related OSC commands.
Handles OSC 4 (Color Palette Set/Query) commands.
Handles parsing of color specifications in various formats.
Handles cursor and font-related OSC commands.
Handles parsing of font-related OSC commands.
Parser for hyperlink data in OSC commands.
Handles OSC 51 (Selection) commands.
Handles parsing of selection-related OSC commands.
Handles OSC (Operating System Command) sequences for window operations.
Provides parameter validation functions for CSI command handlers.
Handles parsing of command parameters in terminal sequences.
Manages terminal commands with advanced features
Handles screen manipulation commands in the terminal.
Handles scrolling operations for the terminal screen buffer.
Handles window-related commands and operations for the terminal.
Handles terminal settings and behavior, including
Manages caching for terminal animations using the unified caching system.
Terminal configuration application.
Terminal capability detection and management.
Default terminal configuration values.
Defines the behaviour for terminal environment configuration.
Handles persistence and migration of terminal configurations.
Terminal configuration profile management.
Schema definitions for terminal configuration.
Utility functions for handling terminal configuration maps.
Validation logic for terminal configuration.
Validates terminal configuration settings.
Configuration management for the terminal emulator.
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.
Provides cursor manipulation functions for the terminal emulator. This module handles operations like moving the cursor, setting its visibility, and managing cursor state.
Manages cursor state and operations in the terminal. Handles cursor position, visibility, style, and blinking state.
Handles cursor movement and positioning for the terminal emulator.
Handles cursor style and visibility control for the terminal emulator.
Handles device status reporting and attributes 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.
Provides buffer management functionality for the terminal emulator.
Handles cursor operations for the terminal emulator.
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.
Provides terminal emulator structure and related functionality.
Handles text styling and formatting for the terminal emulator. Provides functions for managing character attributes, colors, and text formatting.
Defines the behaviour for terminal emulator style management. This includes handling text attributes, colors, and text formatting.
Defines the behaviour for the core Terminal Emulator.
Common utilities for parsing escape sequences.
Parser for Control Sequence Introducer (CSI) escape sequences.
Parser for Select Character Set (SCS) escape sequences.
Handles parsing of ANSI escape sequences and other control sequences.
Handles processing of terminal events and their effects on the terminal state.
Handles terminal events and dispatches them to appropriate handlers.
Example implementation of Raxol.Terminal.Manager.Callback. This module logs each event it receives. Use as a template for your own callback modules.
Manages terminal extensions with advanced features
Unified extension system for the Raxol terminal emulator. Handles extension management, integration, and communication with the terminal.
Manages font operations and settings for the terminal, including font family, size, weight, and style.
Manages terminal text formatting and styling operations.
Manages the terminal text formatting.
Manages terminal graphics operations including
Provides unified graphics capabilities for the terminal emulator. This module handles graphics rendering, image display, and graphics state management.
Manages terminal hyperlinks and their states.
Unified input/output system for the terminal emulator.
Handles input processing for the terminal.
Manages input buffering for the terminal emulator.
Handles character processing, translation, and writing to the terminal buffer.
Handles clipboard operations for the terminal emulator.
Handles various control sequences for the terminal emulator. Includes CSI, OSC, DCS, PM, and APC sequence handling.
Core input handling functionality for the terminal emulator. Manages the main input buffer and cursor state.
Defines the base event struct and common types for input events.
Represents a keyboard input event.
Represents a mouse input event.
Handles input buffering for the terminal emulator. Provides functionality for storing, retrieving, and manipulating input data.
Utility functions for Raxol.Terminal.Input.InputBuffer.
Manages terminal input operations with advanced features
Processes input events for the terminal emulator.
Handles special key combinations and their escape sequences.
Defines shared types for the Raxol terminal input subsystem.
Main input handler module that coordinates between different input handling components.
Coordinates terminal integration components and provides a unified interface for terminal operations.
Handles buffer and cursor management for the terminal.
Manages configuration for the terminal integration.
Handles terminal output rendering and display management using Termbox2.
Manages the state of the integrated terminal system.
Terminal manager module.
Behaviour for terminal manager event callbacks. Implement this behaviour to receive notifications for terminal events.
Handles terminal events and dispatches them to appropriate handlers.
Handles screen updates and batch operations.
Handles terminal session management.
Manages memory usage and limits for the terminal emulator.
Manages terminal metrics and statistics collection, including performance metrics, usage statistics, and error tracking.
Unified metrics system for the Raxol terminal emulator. This module provides centralized metrics collection for
Manages terminal modes for the terminal emulator.
Manages terminal modes (DEC Private Modes, Standard Modes) and their effects.
Handles saved state operations for the mode manager. This includes saving and restoring cursor positions, screen states, and other terminal modes.
Manages terminal mode state and transitions.
Handles terminal modes and state transitions for the terminal emulator.
Handles DEC Private mode operations and their side effects. Manages the implementation of DEC private mode changes and their effects on the terminal.
Handles mouse mode operations and their side effects. Manages different mouse reporting modes and their effects on the terminal.
Handles screen buffer mode operations and their side effects. Manages alternate screen buffer switching and related functionality.
Handles standard mode operations and their side effects. Manages standard terminal modes like insert mode and line feed mode.
Manages the state of terminal modes, including transitions and validation. Handles mode dependencies, conflicts, and state persistence.
Defines types and constants for terminal modes. Provides a centralized registry of all terminal modes and their properties.
Manages mouse events and tracking in the terminal, including button clicks, movement, and wheel events.
Provides unified mouse handling functionality for the terminal emulator. This module handles mouse events, tracking, and state management.
Manages terminal notifications, telemetry events, and callbacks.
Manages terminal output buffering and control sequences.
Processes output events for the terminal emulator.
Manages terminal output buffering, control sequences, and formatting. Provides functionality for
Parses raw byte streams into terminal events and commands. Handles escape sequences (CSI, OSC, DCS, etc.) and plain text.
Parser state for the terminal emulator.
Manages the state of the terminal parser, including escape sequences, control sequences, and parser modes.
Defines the behaviour for parser states.
Behaviour for terminal parser state management.
Handles the CSI Entry state in the terminal parser. This state is entered after receiving an ESC [ sequence.
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 parsing in the ground state, the default state of the terminal.
Handles the :osc_string_maybe_st state of the terminal parser.
Handles the OSC String state in the terminal parser. This state is entered when an OSC sequence is initiated.
Manages terminal plugins with advanced features
Unified plugin system for the Raxol terminal emulator. Handles themes, scripting, and extensions.
Core functionality for managing terminal plugins.
Terminal registry module.
Provides a unified interface for terminal rendering operations.
Terminal renderer module.
GPU-accelerated terminal renderer.
Provides screen manipulation functions for the terminal emulator.
Manages the terminal's screen buffer state (grid, scrollback, selection). This module serves as the main interface for terminal buffer operations, delegating specific operations to specialized modules in Raxol.Terminal.Buffer.*.
Handles CSI (Control Sequence Introducer) sequences for the screen buffer.
Handles character set operations for the screen buffer.
Manages cloud-related settings for the screen buffer.
Core implementation of the screen buffer functionality. Implements the Raxol.Terminal.ScreenBufferBehaviour.
Handles file system event monitoring for the terminal screen buffer. This module provides functions for processing file system events and managing debounced event handling.
Handles text formatting operations for the screen buffer.
Handles metrics collection and management for the terminal screen buffer. This module provides functions for recording and retrieving various metrics related to screen buffer performance, operations, and resource usage.
Handles terminal mode state management.
Handles output buffer operations for the terminal screen buffer. This module manages the output buffer state and provides functions for writing, flushing, and clearing the buffer.
Manages screen buffer preferences and settings.
Handles screen buffer operations for the terminal emulator. This module provides functions for managing the screen state, including clearing, erasing, and marking damaged regions.
Handles scroll state management for the terminal screen buffer.
Handles terminal state operations for the screen buffer.
Manages system-related settings for the screen buffer.
Manages themes for the screen buffer.
Handles screen visualization and chart creation.
Defines the behaviour for screen buffer operations in the terminal. This module specifies the callbacks that must be implemented by any module that wants to act as a screen buffer.
Manages screen buffer operations for the terminal emulator. This module handles operations related to the main and alternate screen buffers, including buffer switching, initialization, and state management.
Manages terminal screen state and updates.
Unified scripting system for the Raxol terminal emulator. Handles script execution, management, and integration with the terminal.
Manages terminal scrolling operations with advanced features.
Handles scroll optimization for better performance.
Handles predictive scrolling operations for the terminal.
Handles scroll synchronization across terminal splits.
Unified scroll management system for the terminal.
Manages terminal scrollback buffer operations.
Manages text selection operations in the terminal.
Terminal session module.
Handles serialization and deserialization of terminal session state.
Handles persistence of terminal sessions.
Session management module for handling terminal sessions.
Manages terminal split windows, handling creation, resizing, navigation, and synchronization of split terminal windows.
Supervisor for the terminal split management system.
Handles synchronization between terminal splits, including event broadcasting, state sharing, and communication protocols.
Provides state management for the terminal emulator. This module handles operations like creating new states, saving and restoring states, and managing state transitions.
Manages the overall state of the terminal, including mode settings, cursor state, and terminal dimensions.
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.
Defines the structure for synchronized components.
Manages synchronization between different terminal components (splits, windows, tabs). Provides a high-level interface for component synchronization and state management.
Defines the synchronization protocol for terminal components. Handles message formats, versioning, and conflict resolution strategies.
Unified synchronization system for the terminal emulator. Handles synchronization between splits, windows, and tabs with different consistency levels.
Unified synchronization system for the Raxol terminal emulator. This module provides centralized synchronization mechanisms for
Manages terminal tabs and their associated sessions. This module handles
Provides unified tab management functionality for the terminal emulator. This module handles tab creation, switching, state management, and configuration.
Logs all Raxol.Terminal telemetry events for observability and debugging.
Example integration of Telemetry.Metrics and TelemetryMetricsStatsd for Raxol terminal events.
Example integration of Telemetry.Metrics and TelemetryMetricsPrometheus for Raxol terminal events.
Manages terminal state operations for the terminal emulator. This module handles the state stack, saved states, and state transitions.
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.
Manages terminal themes with advanced features
Unified theme system for the Raxol terminal emulator. Handles theme management, preview, switching, and customization.
Stub validation module for terminal input. Replace with real validation logic as needed.
Represents a terminal window with its properties and state.
Manages terminal window properties and operations.
Registry for managing multiple terminal windows.
Unified window management system for the Raxol Terminal Emulator. Handles window creation, manipulation, state management, and ANSI sequence processing.
Common assertion helpers for Raxol tests. Provides standardized assertions for components, events, and state.
Helper functions for Emulator tests.
Event-based assertion helpers for ExUnit tests. Provides wrappers for assert_receive and refute_receive for event-driven code.
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.
A mock database adapter for testing purposes that implements all required Ecto adapter behaviors.
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.
Provides large sample data and data generation helpers for performance tests.
Provides helper functions for generating complex view structures for performance tests.
Test fixtures for plugin-related tests.
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.
Helper functions for window-related tests.
Analyzes test results and categorizes failures and skipped tests.
Custom ExUnit formatter for Raxol test output.
Provides base functionality and utilities for Raxol components.
Defines the behavior for UI components in the Raxol system.
Provides component lifecycle hooks and management for UI 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.UI.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 containing a text input.
A dashboard widget that displays a treemap using Raxol.UI.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.
A progress bar component for displaying completion status.
A component for displaying tabular data with sorting, filtering, and pagination.
Handles drawing the focus ring around focused components.
Displays contextual hints and keyboard shortcuts.
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.UI.Components.Input.MultiLineInput.ClipboardHelper.
Handles events for the MultiLineInput component.
Helper functions for cursor navigation and text selection in MultiLineInput.
UI adapter for MultiLineInput's RenderHelper. Delegates to the implementation in Raxol.UI.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 simple single-line text input component.
A text field component for single-line text input.
A text input component for capturing user text input.
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.
Handles layout calculations for container elements like rows and columns.
Handles measurement of basic UI elements like text, labels, boxes, and checkboxes.
Core layout engine that translates the logical view structure into absolute positions.
Handles layout calculations for grid UI elements.
Handles measurement of input elements like buttons and text inputs.
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.
Helper module for renderer tests providing common test utilities and fixtures.
Manages the rendering pipeline for the UI as a GenServer.
GenServer responsible for managing rendering state and applying animation settings. Receives commands from the rendering pipeline and coordinates rendering actions.
Provides functions to compute the difference (diff) between two UI trees. This module is responsible for identifying changes, additions, removals, and reordering of nodes, supporting both keyed and non-keyed children.
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.
A LiveView for a code playground that allows users to write, edit, and run code snippets.
WebSocket channel for real-time terminal communication.
LiveView component for the terminal interface.
A view for rendering UI components.
Provides authentication plugs and helpers.
Handles user registration.
Handles user session management (login/logout).
Mix Tasks
Runs visualization performance benchmarks.