yoopta-editor/Yoopta-Editor

Features

• Block-Based Data Models - Utilizes a structured hierarchy of independent content blocks and inline elements as the core data model.
• Plugin-Based Editor Extensibility - Implements a highly extensible plugin system for defining custom content blocks and editor behavior.
• Block Editor Compositions - Provides a framework for assembling customizable editors by registering structured content blocks and widgets.
• Real-time Collaborative Editors - Provides real-time multi-user synchronization of editor state and remote cursor tracking.
• Rich Text Authoring - Supports creating structured documents with integrated tables, code blocks, and mathematical expressions.
• Multi-Format Exports - Exports editor state into multiple distinct formats including HTML, Markdown, plain text, and structured JSON.
• Block Data Schemas - Generates structured data objects and metadata schemas for blocks prior to their insertion into the document.
• Hierarchical Heading Generation - Provides titled block types to establish a hierarchical document structure.
• Document State Management - Manages the retrieval and replacement of the current document state and emptiness verification.
• Block-Based Content Modification - Provides programmatic interfaces for modifying block metadata such as alignment and depth.
• Structured Table Editors - Provides an administrative interface for building tabular structures, including inserting, deleting, and resizing rows and columns.
• Atomic Document Transforms - Groups multiple block or element changes into single atomic transforms to ensure consistent document updates.
• Content Change Tracking - Provides a system for tracking content state changes and operation lists as a document is edited.
• Editor Slash Commands - Provides a keyboard-driven slash command interface for inserting various content blocks into the editor.
• Hyperlink Management - Provides tools for inserting and managing inline links and link blocks.
• Collaboration History Management - Manages undo and redo operations that allow users to revert local changes without affecting collaborators.
• Headless Architectures - Decouples document state and logic from the visual layer to allow fully custom UI implementations.
• JSON-Based Document Engines - Utilizes a JSON-based document engine to manage editor state and facilitate multi-format serialization.
• Hook-Based Plugin Systems - Uses a registry of plugins and lifecycle hooks to define new block types and commands.
• Sync Conflict Resolution - Ensures state convergence across multiple users using conflict-resolution mechanisms for real-time synchronization.
• Undo-Redo Management - Implements a history stack for the reversion and reapplication of document changes via undo and redo operations.
• Content Block Editors - Provides contextual floating buttons and menus for managing and transforming structured content blocks.
• Block Data Retrieval - Implements efficient fetching of block metadata and internal content via IDs or positional indices.
• Block Merging Operations - Provides the ability to combine a source block into a target block while preserving content.
• Block Nesting Management - Allows users to increase or decrease block depth to create visually nested hierarchies.
• Block Order Management - Allows changing a block's position within the document by assigning a new order index.
• Block Splitting Operations - Enables the division of a single block into two separate blocks at the current cursor position.
• Block Type Conversion - Allows transforming a block from one type to another while preserving the existing text content.
• Editor Plugins - Offers an extensible plugin system to define new content blocks, text marks, and rendering logic.
• Editor UI Components - Provides a set of reusable UI components for building toolbars, menus, and other editor interface elements.
• Focus Management - Provides programmatic control over keyboard focus and interaction states for specific blocks and nodes.
• Editor Image Uploaders - Supports adding images via uploads or URLs with resizing and responsiveness controls.
• Real-Time Collaborative Editing - Synchronizes document state across multiple users with remote cursors and real-time conflict resolution.
• Rich Text Editors - Provides a headless framework for building document editors based on a structured block-based data model.
• Headless Frameworks - Separates core document state management and editing logic from the visual presentation layer.
• Rich Media Document Handling - Provides a system for integrating non-editable media blocks and metadata within a structured text stream.
• Rich Text WYSIWYG Editors - Provides a visual editing interface for creating structured documents with complex layouts.
• Text Formatting Tools - Provides utilities for applying stylistic marks like bold, italic, and underline to text.
• Table Data Serializers - Transforms HTML table tags into editor elements and serializes tabular data into Markdown.
• Content Discovery & Organization - Organizes related information into switchable sections for toggling between different content views.
• Text Style Definitions - Provides the ability to define unique text formatting styles with custom rendering components.
• Inline File Embedding - Supports uploading files to a server and embedding them as interactive blocks with metadata.
• Dynamic List Generators - Generates bulleted, numbered, and checkable todo lists to organize structured document content.
• HTML Serialization - Converts structured internal code block representations into HTML, Markdown, or email-compatible text strings.
• Image Serializers - Converts image elements into standard HTML tags or Markdown syntax for document export.
• Cell Range Selection - Implements visual highlighting of cell ranges within tables for bulk operations.
• Mention Systems - Provides a searchable dropdown for selecting and inserting entities like people or channels.
• Undo-Redo State History - Tracks document changes as atomic operations in a history stack to support local undo and redo.
• Dynamic Plugin Registrations - Supports registering and unregistering plugins at runtime to dynamically modify available block types.
• Editor Event Handlers - Implements listeners for state changes and user actions to trigger custom logic via an event-driven API.
• Video Embeddings - Provides tools for integrating external video content from hosting platforms directly into the editor.
• LaTeX Math Rendering - Embeds LaTeX mathematical expressions into text blocks that render as formatted math.
• Plugin Extenders - Allows for the creation of complex content structures through nested and extended plugins.
• Collapse Sections - Provides interactive accordion blocks that allow users to toggle the visibility of content sections.
• Theme Mappings - Maps headless logic to pre-styled UI components through a theme provider for standardized appearance.
• Custom Block Definitions - Allows replacing default paragraph displays with custom components to implement features like character counters.
• Content Embedding Tools - Integrates media from external platforms by detecting URLs and rendering responsive containers.
• Email - Transforms complex editor sections into table-based layouts to ensure consistent rendering across various email clients.
• Mathematical Expression Serializers - Serializes mathematical expressions into HTML, Markdown, and email-compatible formats for consistent rendering.
• Custom Text Marks - Enables the creation of unique text formatting styles with specialized render logic.
• Table Rendering Overrides - Supports the override of default table, row, and cell visuals using custom React components.
• Drag-and-Drop Row Reorderers - Implements a visual drag-and-drop interface for rearranging the sequence of content blocks.
• Editor Themes - Implements CSS-based theme mapping and variable overrides for customizing the visual appearance of the editor.
• Property Editing Panels - Provides a dedicated options panel for editing properties of elements like links and images.
• Floating Action Buttons - Ships action buttons that float above content blocks on hover to provide quick access to context-specific controls.
• Floating Toolbars - Implements a contextual floating toolbar that appears automatically when text is selected for quick formatting.
• Photo and Video Uploads - Implements the transmission of video files and thumbnails to server-side API endpoints.
• Cell Merging - Allows for merging, splitting, and clearing of table cells while managing alignment and background colors.
• HTML Content Processing - Provides utilities for parsing and synchronizing collapsible blocks between raw HTML and the structured document model.
• Sequential Instruction Lists - Implements numbered, step-by-step lists with the ability to dynamically add or remove instructional items.
• Pluggable Image Uploaders - Allows transmitting image files to specified API endpoints or custom functions for cloud storage.
• Image Rendering Overrides - Supports replacing the default image block representation with custom React components.
• Syntax Highlighters - Renders code blocks with configurable themes and support for multiple programming languages.
• Tabbed Containers - Provides the ability to override the visual layout and appearance of tabbed content containers.
• Mentioning Systems - Defines custom visual styles and interactive dropdowns for mentioning entities within the editor.
• CSS Variable Override Themes - Utilizes CSS variables and tokens to override the visual appearance and color palette of the interface.
• Visual Themes - Attaches pre-styled UI components to headless plugins to standardize the application's visual identity.
• Presence Indicators - Displays active users and the specific blocks they are editing via visual indicators and remote cursors.
• Structured Document Serialization - Converts internal structured block data into HTML, Markdown, and JSON using a defined mapping system.

Star history