rte-builder 1.0.0 → 2.0.2

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import * as react from 'react';
-import react__default from 'react';
+import react__default, { ReactNode } from 'react';
 import { Editor } from '@tiptap/react';
 import { Extension, Node } from '@tiptap/core';
+import * as react_jsx_runtime from 'react/jsx-runtime';
 
 /**
  * Core types for the RTE Builder - Editor Agnostic
@@ -687,4 +688,539 @@ declare module '@tiptap/core' {
 }
 declare const Indent: Extension<IndentOptions, any>;
 
-export { type AdapterComponentProps, type AdapterEditorRef, type BaseEditorConfig, DEFAULT_FEATURES, EMOJI_CATEGORIES, type EditorAdapter, type EditorFeatures, type EditorProps, type EditorRef, EditorRegistry, type EditorType, Emoji, FontSize, Fullscreen, Indent, type MediaFile as LegacyMediaFile, type ToolbarConfig as LegacyToolbarConfig, LineHeight, type MediaFile$1 as MediaFile, Print, RichTextEditor, TipTapAdapter, TipTapEditorComponent, TipTapToolbar, type ToolbarButton, type ToolbarButtonType, type ToolbarConfig$1 as ToolbarConfig, type ToolbarPreset, type ToolbarPresetName, UnifiedEditor, type UnifiedEditorProps, type UnifiedEditorRef, Video, blogToolbar, codeToolbar, compareEditorFeatures, customizeToolbar, emailToolbar, fullToolbar, getAdapter, getAllAdapters, getAvailableAdapters, getBestAvailableEditor, getDefaultEditorType, getEditorFeatures, getRegistryStats, getToolbarPreset, isEditorAvailable, mediumToolbar, minimalToolbar, registerAdapter, simpleToolbar, toolbarPresets, unregisterAdapter };
+/**
+ * Collaboration Types
+ * Types for real-time collaborative editing features
+ */
+/** User presence information */
+interface CollaborationUser {
+    /** Unique user identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Avatar URL (optional) */
+    avatar?: string;
+    /** User color for cursor/selection */
+    color: string;
+    /** Current cursor position (optional) */
+    cursor?: CursorPosition;
+    /** Whether user is currently active */
+    isActive: boolean;
+    /** Last activity timestamp */
+    lastActive: number;
+}
+/** Cursor position in the document */
+interface CursorPosition {
+    /** Position index in the document */
+    index: number;
+    /** Length of selection (0 if just cursor) */
+    length: number;
+}
+/** Collaboration provider configuration */
+interface CollaborationConfig {
+    /** Provider type */
+    provider: 'websocket' | 'webrtc' | 'custom';
+    /** Server URL for websocket/webrtc */
+    serverUrl?: string;
+    /** Room/document identifier */
+    roomId: string;
+    /** Current user information */
+    user: Omit<CollaborationUser, 'cursor' | 'isActive' | 'lastActive'>;
+    /** Authentication token (optional) */
+    token?: string;
+    /** Auto-reconnect on disconnect */
+    autoReconnect?: boolean;
+    /** Reconnect interval in ms */
+    reconnectInterval?: number;
+    /** Maximum reconnect attempts */
+    maxReconnectAttempts?: number;
+}
+/** Collaboration connection status */
+type CollaborationStatus = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
+/** Collaboration state */
+interface CollaborationState {
+    /** Connection status */
+    status: CollaborationStatus;
+    /** Connected users */
+    users: CollaborationUser[];
+    /** Error message if status is 'error' */
+    error?: string;
+    /** Is current user the host/owner */
+    isHost: boolean;
+}
+/** Collaboration event types */
+type CollaborationEvent = {
+    type: 'user-joined';
+    user: CollaborationUser;
+} | {
+    type: 'user-left';
+    userId: string;
+} | {
+    type: 'cursor-moved';
+    userId: string;
+    cursor: CursorPosition;
+} | {
+    type: 'content-changed';
+    origin: string;
+} | {
+    type: 'status-changed';
+    status: CollaborationStatus;
+} | {
+    type: 'error';
+    message: string;
+};
+/** Props for collaboration-enabled editor */
+interface CollaborationProps {
+    /** Enable collaboration features */
+    collaboration?: CollaborationConfig;
+    /** Callback when collaboration status changes */
+    onCollaborationStatusChange?: (status: CollaborationStatus) => void;
+    /** Callback when users join/leave */
+    onUsersChange?: (users: CollaborationUser[]) => void;
+    /** Show user cursors */
+    showCursors?: boolean;
+    /** Show user avatars in presence list */
+    showPresence?: boolean;
+}
+
+/** Context value type */
+interface CollaborationContextValue {
+    state: CollaborationState;
+    config: CollaborationConfig | null;
+    connect: () => Promise<void>;
+    disconnect: () => void;
+    updateCursor: (cursor: CursorPosition) => void;
+    isEnabled: boolean;
+}
+/** Provider props */
+interface CollaborationProviderProps {
+    children: ReactNode;
+    config?: CollaborationConfig;
+    onStatusChange?: (status: CollaborationStatus) => void;
+    onUsersChange?: (users: CollaborationUser[]) => void;
+}
+/** Collaboration Provider Component */
+declare function CollaborationProvider({ children, config, onStatusChange, onUsersChange, }: CollaborationProviderProps): react_jsx_runtime.JSX.Element;
+/** Hook to use collaboration context */
+declare function useCollaboration(): CollaborationContextValue;
+/** Hook to check if collaboration is available (doesn't throw) */
+declare function useCollaborationOptional(): CollaborationContextValue | null;
+
+/**
+ * Presence Indicator Component
+ * Shows connected users with avatars and status
+ */
+interface PresenceIndicatorProps {
+    /** Maximum avatars to show before "+N" */
+    maxAvatars?: number;
+    /** Show user names on hover */
+    showNames?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+/** Presence Indicator Component */
+declare function PresenceIndicator({ maxAvatars, showNames, className, }: PresenceIndicatorProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * Comments & Annotations Types
+ * Types for inline comments and annotation features
+ */
+/** Comment author information */
+interface CommentAuthor {
+    /** Unique user identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Avatar URL (optional) */
+    avatar?: string;
+}
+/** Text range for comment anchor */
+interface CommentRange {
+    /** Start position in document */
+    from: number;
+    /** End position in document */
+    to: number;
+    /** Selected text content */
+    text: string;
+}
+/** Single comment in a thread */
+interface Comment {
+    /** Unique comment identifier */
+    id: string;
+    /** Thread this comment belongs to */
+    threadId: string;
+    /** Comment content (can be HTML) */
+    content: string;
+    /** Comment author */
+    author: CommentAuthor;
+    /** Creation timestamp */
+    createdAt: number;
+    /** Last update timestamp */
+    updatedAt?: number;
+    /** Is this comment edited */
+    isEdited: boolean;
+    /** Reactions on this comment */
+    reactions?: CommentReaction[];
+}
+/** Reaction on a comment */
+interface CommentReaction {
+    /** Emoji reaction */
+    emoji: string;
+    /** Users who reacted */
+    users: CommentAuthor[];
+}
+/** Comment thread (group of comments on a text range) */
+interface CommentThread {
+    /** Unique thread identifier */
+    id: string;
+    /** Text range this thread is attached to */
+    range: CommentRange;
+    /** Comments in this thread */
+    comments: Comment[];
+    /** Thread status */
+    status: 'open' | 'resolved';
+    /** Thread creation timestamp */
+    createdAt: number;
+    /** Thread resolution timestamp */
+    resolvedAt?: number;
+    /** User who resolved the thread */
+    resolvedBy?: CommentAuthor;
+}
+/** Comments state */
+interface CommentsState {
+    /** All comment threads */
+    threads: CommentThread[];
+    /** Currently active/selected thread ID */
+    activeThreadId: string | null;
+    /** Is comment panel open */
+    isPanelOpen: boolean;
+    /** Filter for threads */
+    filter: 'all' | 'open' | 'resolved';
+    /** Current user (for adding comments) */
+    currentUser: CommentAuthor | null;
+}
+/** Comment event types */
+type CommentEvent = {
+    type: 'thread-created';
+    thread: CommentThread;
+} | {
+    type: 'thread-deleted';
+    threadId: string;
+} | {
+    type: 'thread-resolved';
+    threadId: string;
+    resolvedBy: CommentAuthor;
+} | {
+    type: 'thread-reopened';
+    threadId: string;
+} | {
+    type: 'comment-added';
+    threadId: string;
+    comment: Comment;
+} | {
+    type: 'comment-updated';
+    threadId: string;
+    comment: Comment;
+} | {
+    type: 'comment-deleted';
+    threadId: string;
+    commentId: string;
+} | {
+    type: 'reaction-added';
+    threadId: string;
+    commentId: string;
+    emoji: string;
+    user: CommentAuthor;
+} | {
+    type: 'reaction-removed';
+    threadId: string;
+    commentId: string;
+    emoji: string;
+    userId: string;
+};
+/** Comments configuration */
+interface CommentsConfig {
+    /** Current user for adding comments */
+    currentUser: CommentAuthor;
+    /** Allow resolving threads */
+    allowResolve?: boolean;
+    /** Allow deleting comments */
+    allowDelete?: boolean;
+    /** Allow editing comments */
+    allowEdit?: boolean;
+    /** Allow reactions */
+    allowReactions?: boolean;
+    /** Available reaction emojis */
+    reactionEmojis?: string[];
+    /** Callback to persist comments */
+    onSave?: (threads: CommentThread[]) => Promise<void>;
+    /** Callback to load comments */
+    onLoad?: () => Promise<CommentThread[]>;
+}
+/** Props for comments-enabled editor */
+interface CommentsProps {
+    /** Enable comments features */
+    comments?: CommentsConfig;
+    /** Initial comment threads */
+    initialThreads?: CommentThread[];
+    /** Callback when threads change */
+    onThreadsChange?: (threads: CommentThread[]) => void;
+    /** Show comment highlights in editor */
+    showCommentHighlights?: boolean;
+    /** Show comment panel */
+    showCommentPanel?: boolean;
+    /** Comment panel position */
+    commentPanelPosition?: 'left' | 'right';
+}
+/** Default reaction emojis */
+declare const DEFAULT_REACTION_EMOJIS: string[];
+
+/** Context value type */
+interface CommentsContextValue {
+    state: CommentsState;
+    config: CommentsConfig | null;
+    createThread: (range: CommentRange, initialComment: string) => CommentThread | null;
+    deleteThread: (threadId: string) => void;
+    resolveThread: (threadId: string) => void;
+    reopenThread: (threadId: string) => void;
+    addComment: (threadId: string, content: string) => Comment | null;
+    updateComment: (threadId: string, commentId: string, content: string) => void;
+    deleteComment: (threadId: string, commentId: string) => void;
+    addReaction: (threadId: string, commentId: string, emoji: string) => void;
+    removeReaction: (threadId: string, commentId: string, emoji: string) => void;
+    setActiveThread: (threadId: string | null) => void;
+    togglePanel: (isOpen?: boolean) => void;
+    setFilter: (filter: 'all' | 'open' | 'resolved') => void;
+    getThreadByRange: (from: number, to: number) => CommentThread | undefined;
+    getFilteredThreads: () => CommentThread[];
+    subscribe: (callback: (event: CommentEvent) => void) => () => void;
+    isEnabled: boolean;
+}
+/** Provider props */
+interface CommentsProviderProps {
+    children: ReactNode;
+    config?: CommentsConfig;
+    initialThreads?: CommentThread[];
+    onThreadsChange?: (threads: CommentThread[]) => void;
+}
+/** Comments Provider Component */
+declare function CommentsProvider({ children, config, initialThreads, onThreadsChange, }: CommentsProviderProps): react_jsx_runtime.JSX.Element;
+/** Hook to use comments context */
+declare function useComments(): CommentsContextValue;
+/** Hook to check if comments is available (doesn't throw) */
+declare function useCommentsOptional(): CommentsContextValue | null;
+
+/**
+ * Comments Panel Component
+ * Displays comment threads with reply functionality
+ */
+interface CommentsPanelProps {
+    /** Panel position */
+    position?: 'left' | 'right';
+    /** Custom class name */
+    className?: string;
+}
+/** Comments Panel Component */
+declare function CommentsPanel({ position, className }: CommentsPanelProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * Version History Types
+ * Types for document version history and change tracking
+ */
+/** Author of a version */
+interface VersionAuthor {
+    /** Unique user identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Avatar URL (optional) */
+    avatar?: string;
+}
+/** A single version/snapshot of the document */
+interface Version {
+    /** Unique version identifier */
+    id: string;
+    /** Version number (incremental) */
+    number: number;
+    /** Version title/label (optional) */
+    title?: string;
+    /** Version description (optional) */
+    description?: string;
+    /** HTML content at this version */
+    content: string;
+    /** JSON content (if available) */
+    jsonContent?: unknown;
+    /** Plain text content */
+    textContent: string;
+    /** Author who created this version */
+    author: VersionAuthor;
+    /** Creation timestamp */
+    createdAt: number;
+    /** Word count at this version */
+    wordCount: number;
+    /** Character count at this version */
+    characterCount: number;
+    /** Is this version auto-saved or manual */
+    isAutoSave: boolean;
+    /** Is this a named/pinned version */
+    isPinned: boolean;
+    /** Tags for this version */
+    tags?: string[];
+}
+/** Change between two versions */
+interface VersionChange {
+    /** Type of change */
+    type: 'addition' | 'deletion' | 'modification';
+    /** Content that was changed */
+    content: string;
+    /** Position in document */
+    position: number;
+}
+/** Version comparison result */
+interface VersionComparison {
+    /** Source version ID */
+    fromVersionId: string;
+    /** Target version ID */
+    toVersionId: string;
+    /** List of changes */
+    changes: VersionChange[];
+    /** Summary statistics */
+    stats: {
+        additions: number;
+        deletions: number;
+        modifications: number;
+    };
+}
+/** Version history state */
+interface VersionHistoryState {
+    /** All versions */
+    versions: Version[];
+    /** Currently viewing version ID (null = current) */
+    viewingVersionId: string | null;
+    /** Is history panel open */
+    isPanelOpen: boolean;
+    /** Is comparing versions */
+    isComparing: boolean;
+    /** Version being compared from */
+    compareFromId: string | null;
+    /** Version being compared to */
+    compareToId: string | null;
+    /** Is auto-save enabled */
+    autoSaveEnabled: boolean;
+    /** Auto-save interval in ms */
+    autoSaveInterval: number;
+}
+/** Version history event types */
+type VersionHistoryEvent = {
+    type: 'version-created';
+    version: Version;
+} | {
+    type: 'version-deleted';
+    versionId: string;
+} | {
+    type: 'version-restored';
+    versionId: string;
+} | {
+    type: 'version-pinned';
+    versionId: string;
+} | {
+    type: 'version-unpinned';
+    versionId: string;
+} | {
+    type: 'version-renamed';
+    versionId: string;
+    title: string;
+} | {
+    type: 'auto-save-toggled';
+    enabled: boolean;
+};
+/** Version history configuration */
+interface VersionHistoryConfig {
+    /** Current user for versioning */
+    currentUser: VersionAuthor;
+    /** Enable auto-save */
+    autoSave?: boolean;
+    /** Auto-save interval in ms (default: 60000 = 1 minute) */
+    autoSaveInterval?: number;
+    /** Maximum versions to keep (default: 100) */
+    maxVersions?: number;
+    /** Callback to persist versions */
+    onSave?: (versions: Version[]) => Promise<void>;
+    /** Callback to load versions */
+    onLoad?: () => Promise<Version[]>;
+    /** Callback when version is restored */
+    onRestore?: (version: Version) => void;
+}
+/** Props for version history-enabled editor */
+interface VersionHistoryProps {
+    /** Enable version history features */
+    versionHistory?: VersionHistoryConfig;
+    /** Initial versions */
+    initialVersions?: Version[];
+    /** Callback when versions change */
+    onVersionsChange?: (versions: Version[]) => void;
+    /** Show version history panel */
+    showVersionPanel?: boolean;
+    /** Version panel position */
+    versionPanelPosition?: 'left' | 'right';
+}
+
+/** Context value type */
+interface VersionHistoryContextValue {
+    state: VersionHistoryState;
+    config: VersionHistoryConfig | null;
+    createVersion: (content: string, jsonContent?: unknown, options?: {
+        title?: string;
+        isAutoSave?: boolean;
+    }) => Version | null;
+    deleteVersion: (versionId: string) => void;
+    restoreVersion: (versionId: string) => string | null;
+    pinVersion: (versionId: string) => void;
+    unpinVersion: (versionId: string) => void;
+    renameVersion: (versionId: string, title: string) => void;
+    viewVersion: (versionId: string | null) => void;
+    getVersionContent: (versionId: string) => string | null;
+    compareVersions: (fromId: string, toId: string) => VersionComparison | null;
+    startCompare: (fromId: string, toId: string) => void;
+    stopCompare: () => void;
+    togglePanel: (isOpen?: boolean) => void;
+    setAutoSave: (enabled: boolean) => void;
+    getVersion: (versionId: string) => Version | undefined;
+    getLatestVersion: () => Version | undefined;
+    getPinnedVersions: () => Version[];
+    subscribe: (callback: (event: VersionHistoryEvent) => void) => () => void;
+    isEnabled: boolean;
+}
+/** Provider props */
+interface VersionHistoryProviderProps {
+    children: ReactNode;
+    config?: VersionHistoryConfig;
+    initialVersions?: Version[];
+    onVersionsChange?: (versions: Version[]) => void;
+    getCurrentContent?: () => {
+        html: string;
+        json?: unknown;
+        text: string;
+    };
+}
+/** Version History Provider Component */
+declare function VersionHistoryProvider({ children, config, initialVersions, onVersionsChange, getCurrentContent, }: VersionHistoryProviderProps): react_jsx_runtime.JSX.Element;
+/** Hook to use version history context */
+declare function useVersionHistory(): VersionHistoryContextValue;
+/** Hook to check if version history is available (doesn't throw) */
+declare function useVersionHistoryOptional(): VersionHistoryContextValue | null;
+
+/**
+ * Version History Panel Component
+ * Displays version history with restore and compare functionality
+ */
+interface VersionHistoryPanelProps {
+    /** Panel position */
+    position?: 'left' | 'right';
+    /** Custom class name */
+    className?: string;
+}
+/** Version History Panel Component */
+declare function VersionHistoryPanel({ position, className }: VersionHistoryPanelProps): react_jsx_runtime.JSX.Element | null;
+
+export { type AdapterComponentProps, type AdapterEditorRef, type BaseEditorConfig, type CollaborationConfig, type CollaborationEvent, type CollaborationProps, CollaborationProvider, type CollaborationState, type CollaborationStatus, type CollaborationUser, type Comment, type CommentAuthor, type CommentEvent, type CommentRange, type CommentThread, type CommentsConfig, CommentsPanel, type CommentsProps, CommentsProvider, type CommentsState, type CursorPosition, DEFAULT_FEATURES, DEFAULT_REACTION_EMOJIS, EMOJI_CATEGORIES, type EditorAdapter, type EditorFeatures, type EditorProps, type EditorRef, EditorRegistry, type EditorType, Emoji, FontSize, Fullscreen, Indent, type MediaFile as LegacyMediaFile, type ToolbarConfig as LegacyToolbarConfig, LineHeight, type MediaFile$1 as MediaFile, PresenceIndicator, Print, RichTextEditor, TipTapAdapter, TipTapEditorComponent, TipTapToolbar, type ToolbarButton, type ToolbarButtonType, type ToolbarConfig$1 as ToolbarConfig, type ToolbarPreset, type ToolbarPresetName, UnifiedEditor, type UnifiedEditorProps, type UnifiedEditorRef, type Version, type VersionAuthor, type VersionChange, type VersionComparison, type VersionHistoryConfig, type VersionHistoryEvent, VersionHistoryPanel, type VersionHistoryProps, VersionHistoryProvider, type VersionHistoryState, Video, blogToolbar, codeToolbar, compareEditorFeatures, customizeToolbar, emailToolbar, fullToolbar, getAdapter, getAllAdapters, getAvailableAdapters, getBestAvailableEditor, getDefaultEditorType, getEditorFeatures, getRegistryStats, getToolbarPreset, isEditorAvailable, mediumToolbar, minimalToolbar, registerAdapter, simpleToolbar, toolbarPresets, unregisterAdapter, useCollaboration, useCollaborationOptional, useComments, useCommentsOptional, useVersionHistory, useVersionHistoryOptional };