@synclineapi/mdx-editor 0.1.2 → 1.0.1

package/dist/core/types.d.ts

@@ -1,3 +1,7 @@
+import { CompletionItem, CompletionKind, TokenSegment } from '@synclineapi/editor';
+export type { CompletionItem, CompletionKind, TokenSegment };
+/** Function signature for a plugin-level syntax token provider. */
+export type PluginTokenProvider = (line: string, language: string) => TokenSegment[];
 export interface EditorConfig {
     container: HTMLElement | string;
     /** Initial markdown content */
@@ -14,8 +18,6 @@ export interface EditorConfig {
     placeholder?: string;
     /** Read-only mode */
     readOnly?: boolean;
-    /** Enable scroll sync between editor and preview */
-    scrollSync?: boolean;
     /** Custom renderer overrides */
     renderers?: Record<string, RendererFn>;
     /** Locale / i18n overrides */
@@ -47,6 +49,59 @@ export interface EditorPlugin {
     styles?: string;
     /** Plugin dependencies (names) */
     dependencies?: string[];
+    /**
+     * Autocomplete items this plugin contributes to the code editor.
+     *
+     * These are merged with the built-in MDX completions so that anything
+     * a plugin can insert via the toolbar is also reachable via autocomplete.
+     *
+     * Use `kind: 'snip'` with a `body` template to get Tab-trigger snippet
+     * expansion that matches the toolbar insertion exactly.
+     *
+     * @example
+     * ```ts
+     * completions: [
+     *   {
+     *     label: 'myblock',
+     *     kind: 'snip',
+     *     detail: '<MyBlock> component',
+     *     description: 'Inserts a MyBlock component with optional title.',
+     *     body: '<MyBlock title="$1Title">\n  $2Content here\n</MyBlock>',
+     *   },
+     * ]
+     * ```
+     */
+    completions?: CompletionItem[];
+    /**
+     * Custom syntax token provider for this plugin's MDX constructs.
+     *
+     * Called on every visible line in the code editor **in addition to** the
+     * built-in MDX tokeniser. Return `TokenSegment` objects for the character
+     * ranges you want coloured. Ranges not covered fall back to the base MDX
+     * tokeniser.
+     *
+     * All plugin providers are composed into a single `provideTokens` function
+     * that is passed to the underlying `SynclineEditor`. The result is LRU-
+     * cached by the editor, so the function is only called once per unique
+     * `(text, language)` pair.
+     *
+     * Use `ctx.registerTokenProvider()` inside `init()` when the segments
+     * need to be computed dynamically (e.g. based on runtime config).
+     *
+     * @example
+     * ```ts
+     * provideTokens: (line, _lang) => {
+     *   const segs: TokenSegment[] = [];
+     *   // Highlight <MyBlock component name
+     *   for (const m of line.matchAll(/<\/?( MyBlock)(?=[\s>/])/g)) {
+     *     const s = m.index! + 1 + (m[0][1] === '/' ? 1 : 0);
+     *     segs.push({ cls: 'cls', start: s, end: s + 'MyBlock'.length });
+     *   }
+     *   return segs;
+     * }
+     * ```
+     */
+    provideTokens?: PluginTokenProvider;
 }
 export interface PluginContext {
     /** The editor instance */
@@ -61,6 +116,43 @@ export interface PluginContext {
     registerParser(parser: ParserConfig): void;
     /** Inject CSS */
     injectStyles(css: string): void;
+    /**
+     * Register an autocomplete completion item for the code editor.
+     * Equivalent to declaring `completions` on the plugin definition, but
+     * useful when the items are built dynamically inside `init()`.
+     *
+     * @example
+     * ```ts
+     * ctx.registerCompletion({
+     *   label: 'myblock',
+     *   kind: 'snip',
+     *   detail: '<MyBlock> component',
+     *   body: '<MyBlock title="$1">\n  $2\n</MyBlock>',
+     * });
+     * ```
+     */
+    registerCompletion(item: CompletionItem): void;
+    /**
+     * Register a dynamic token provider for this plugin's MDX syntax.
+     * Equivalent to declaring `provideTokens` on the plugin definition but
+     * useful when the provider needs to be built dynamically inside `init()`.
+     *
+     * Multiple providers registered from the same plugin are all called and
+     * their results merged into the final token list.
+     *
+     * @example
+     * ```ts
+     * ctx.registerTokenProvider((line, _lang) => {
+     *   const segs: TokenSegment[] = [];
+     *   for (const m of line.matchAll(/<\/?( MyBlock)(?=[\s>/])/g)) {
+     *     const s = m.index! + 1 + (m[0][1] === '/' ? 1 : 0);
+     *     segs.push({ cls: 'cls', start: s, end: s + 'MyBlock'.length });
+     *   }
+     *   return segs;
+     * });
+     * ```
+     */
+    registerTokenProvider(fn: PluginTokenProvider): void;
     /** Emit a plugin event */
     emit(event: string, data?: unknown): void;
     /** Listen to events */
@@ -166,6 +258,62 @@ export interface EditorAPI {
     getWordCount(): number;
     /** Get line count */
     getLineCount(): number;
+    /** Show or hide the line-number gutter (virtual rendering) */
+    setLineNumbers(enabled: boolean): void;
+    /** Scroll the editor to make the given 1-indexed line visible */
+    jumpToLine(lineNumber: number): void;
+    /**
+     * Register one or more custom autocomplete items on top of the built-in
+     * MDX completions. Items are merged immediately and appear in the popup
+     * the next time the user types.
+     *
+     * Use `kind: 'snip'` with a `body` template for snippet expansion — the
+     * Tab key or clicking the item inserts the full body with cursor placed
+     * at the first `$1` tab stop.
+     *
+     * Call multiple times to accumulate items. The full list (built-ins +
+     * plugin items + items registered here) is always deduplicated by label.
+     *
+     * @example
+     * ```ts
+     * editor.registerAutoComplete([
+     *   {
+     *     label: 'mycard',
+     *     kind: 'snip',
+     *     detail: '<MyCard> component',
+     *     description: 'Inserts a custom card block.',
+     *     body: '<MyCard title="$1">\n  $2\n</MyCard>',
+     *   },
+     *   { label: 'MyCard', kind: 'cls', detail: 'component' },
+     * ]);
+     * ```
+     */
+    registerAutoComplete(items: CompletionItem | CompletionItem[]): void;
+    /**
+     * Register one or more custom syntax token providers on top of the
+     * built-in MDX tokeniser and any plugin-contributed providers.
+     *
+     * Each provider is called on every visible line in the code editor and
+     * may return `TokenSegment` objects covering the character ranges that
+     * should receive custom syntax colouring. The result is LRU-cached by
+     * the underlying `SynclineEditor`.
+     *
+     * Equivalent to declaring `provideTokens` on a custom `EditorPlugin` —
+     * use whichever is more convenient.
+     *
+     * @example
+     * ```ts
+     * editor.registerSyntaxHighlighter((line, _lang) => {
+     *   const segs: TokenSegment[] = [];
+     *   for (const m of line.matchAll(/<\/?( MyBlock)(?=[\s>/])/g)) {
+     *     const s = m.index! + 1 + (m[0][1] === '/' ? 1 : 0);
+     *     segs.push({ cls: 'cls', start: s, end: s + 'MyBlock'.length });
+     *   }
+     *   return segs;
+     * });
+     * ```
+     */
+    registerSyntaxHighlighter(fn: PluginTokenProvider | PluginTokenProvider[]): void;
 }
 export interface SelectionState {
     start: number;

package/dist/core/ui/AutocompleteController.d.ts

@@ -0,0 +1,58 @@
+/**
+ * AutocompleteController — MDX/Markdown-aware autocomplete popup.
+ *
+ * Adapted from the vreditor.html autocomplete system. Shows suggestions for:
+ * - MDX component tags (Accordion, Card, Tabs, etc.)
+ * - Markdown syntax (headings, bold, lists, code blocks, etc.)
+ * - HTML tags
+ * - Document-based word completions (words already present in the editor)
+ *
+ * The popup is positioned relative to the cursor and supports keyboard
+ * navigation (Arrow Up/Down, Tab/Enter to accept, Escape to dismiss).
+ */
+/** A single autocomplete suggestion. */
+export interface AutocompleteItem {
+    /** Display label shown in the popup */
+    label: string;
+    /** Category kind — drives the badge icon */
+    kind: 'tag' | 'md' | 'html' | 'var' | 'snippet';
+    /** Short description shown next to label */
+    detail: string;
+    /** Text to insert (defaults to label if omitted) */
+    insertText?: string;
+}
+export declare class AutocompleteController {
+    private popup;
+    private items;
+    private selected;
+    private prefix;
+    private startPos;
+    private textarea;
+    private editorRoot;
+    private _onAccept;
+    /** Additional items registered at runtime by plugins. */
+    private extraItems;
+    constructor(textarea: HTMLTextAreaElement, editorRoot: HTMLElement);
+    /** Register additional completion items (e.g. from plugins). */
+    registerItems(items: AutocompleteItem[]): void;
+    /** Whether the popup is currently visible. */
+    isVisible(): boolean;
+    /** Trigger autocomplete based on current cursor context. */
+    trigger(): void;
+    /** Move selection up or down. */
+    move(dir: number): void;
+    /** Accept the current selection. */
+    accept(): void;
+    /** Set a callback to fire after an item is accepted (for triggering onInput). */
+    onAccept(fn: () => void): void;
+    /** Handle keyboard events. Returns true if the event was consumed. */
+    handleKeyDown(e: KeyboardEvent): boolean;
+    /** Hide the autocomplete popup. */
+    hide(): void;
+    /** Render the popup items. */
+    private render;
+    /** Position the popup near the cursor. */
+    private position;
+    /** Clean up DOM. */
+    destroy(): void;
+}

package/dist/core/ui/DropdownController.d.ts

@@ -0,0 +1,8 @@
+export declare class DropdownController {
+    private activeDropdown;
+    private documentClickHandler;
+    constructor();
+    toggle(menu: HTMLElement, wrapper: HTMLElement): void;
+    closeAll(): void;
+    destroy(): void;
+}

package/dist/core/ui/FindReplaceController.d.ts

@@ -0,0 +1,60 @@
+/**
+ * FindReplaceController — Find & Replace panel for the editor.
+ *
+ * Adapted from the vreditor.html find/replace system. Provides:
+ * - Ctrl+F to open find, Ctrl+H to open find+replace
+ * - Case-sensitive toggle
+ * - Regex search toggle
+ * - Whole-word match toggle
+ * - Navigate between matches (Enter / Shift+Enter or arrows)
+ * - Replace current / Replace all
+ * - Escape to close
+ */
+export declare class FindReplaceController {
+    private panel;
+    private findInput;
+    private replaceInput;
+    private replaceRow;
+    private countLabel;
+    private caseSensitiveBtn;
+    private regexBtn;
+    private wholeWordBtn;
+    private textarea;
+    private editorRoot;
+    private matches;
+    private currentMatch;
+    private caseSensitive;
+    private useRegex;
+    private wholeWord;
+    private showReplace;
+    private _onInputCallback;
+    constructor(textarea: HTMLTextAreaElement, editorRoot: HTMLElement);
+    /** Set a callback to fire after a replace operation (for triggering onInput). */
+    onInput(fn: () => void): void;
+    /** Open the find panel. If `withReplace` is true, also show the replace row. */
+    open(withReplace?: boolean): void;
+    /** Close the find panel. */
+    close(): void;
+    /** Whether the panel is open. */
+    isOpen(): boolean;
+    /** Run the search. */
+    private search;
+    /** Go to next match. */
+    private next;
+    /** Go to previous match. */
+    private prev;
+    /** Select the current match in the textarea. */
+    private highlightCurrent;
+    /** Update the match count label. */
+    private updateCount;
+    /** Replace the current match. */
+    private replaceCurrent;
+    /** Replace all matches. */
+    private replaceAll;
+    /** Create a toggle button. */
+    private createToggle;
+    /** Create an action button. */
+    private createActionBtn;
+    /** Clean up. */
+    destroy(): void;
+}

package/dist/core/ui/LineNumberController.d.ts

@@ -0,0 +1,218 @@
+/**
+ * Virtual line-number gutter — unified scroll container approach.
+ *
+ * Only ~(visible lines + 2×OVERSCAN) DOM nodes live in the DOM at any time,
+ * regardless of document size. For a 10,000-line file only ~40 <span> elements
+ * are ever created; a 100-line file and a 10,000-line file feel identical.
+ *
+ * Layout model (unified scroll container):
+ *
+ *   .smdx-scroll-wrapper           overflow-y:auto — SINGLE scroll container
+ *     ├─ .smdx-line-gutter         flex-shrink:0, position:relative
+ *     │    └─ .smdx-gutter-inner   position:relative, height = totalHeight
+ *     │         └─ <span>          position:absolute, top = lineOffset + paddingTop
+ *     └─ <textarea>                flex:1, overflow:hidden, height auto-sized
+ *
+ * The gutter and textarea are flex siblings inside a shared scroll wrapper.
+ * When the wrapper scrolls, both children scroll together naturally — like
+ * a flex row per line.  No JS-based transform synchronisation is needed.
+ *
+ * Virtual rendering:
+ *   • recyclePool() computes the visible range from the scroll wrapper's
+ *     scrollTop and clientHeight.
+ *   • If the range hasn't changed (OVERSCAN has buffered all visible lines),
+ *     it returns immediately — zero DOM reads, zero DOM writes.
+ *   • Only when lines enter or leave the overscan region are a handful of
+ *     span properties updated (style.top + textContent).
+ *
+ * Multi-line wrapping:
+ *   • For each logical line, rowCount() measures how many visual rows it takes
+ *     using a hidden mirror div with identical font/width settings.
+ *   • heights[i] = rowCount(i) × lineHeightPx (full multi-row height stored).
+ *   • The line-number span for line i is only 1 row tall — pinned to the first
+ *     visual row (VS Code convention).  offsets[] accounts for the full height
+ *     so successive numbers are correctly spaced.
+ */
+/** Public snapshot of the gutter's virtual-rendering state. */
+export interface GutterStats {
+    /** Number of logical lines in the document. */
+    lineCount: number;
+    /** 1-indexed first line currently in the DOM pool. */
+    visibleFirst: number;
+    /** 1-indexed last line currently in the DOM pool. */
+    visibleLast: number;
+    /** Number of <span> elements currently in the DOM. */
+    domNodes: number;
+    /** Computed total content height (px). */
+    totalHeight: number;
+    /** Whether the gutter / virtual renderer is enabled. */
+    enabled: boolean;
+}
+export declare class LineNumberController {
+    private gutter;
+    private textarea;
+    /** The shared scroll wrapper (parent of gutter + textarea). */
+    private scrollEl;
+    private enabled;
+    private mirror;
+    private rafPending;
+    private scrollRafId;
+    private offsets;
+    private heights;
+    private totalHeight;
+    private lineCount;
+    private lineHeightPx;
+    private contentWidth;
+    private avgCharWidth;
+    private paddingTop;
+    private cachedClientHeight;
+    private static readonly WRAP_THRESHOLD;
+    /**
+     * Documents above this line count skip per-line mirror-div measurement
+     * in the synchronous path and use pure character-width estimation instead.
+     * This keeps large pastes (2000+ lines) instant while keeping the gutter
+     * correct for typical editing sessions.
+     */
+    private static readonly LARGE_DOC_THRESHOLD;
+    /**
+     * Delay (ms) before running the deferred precision pass for large documents.
+     * Short enough to feel immediate, long enough to let paste events settle.
+     */
+    private static readonly DEFERRED_UPDATE_DELAY_MS;
+    /**
+     * Minimum content-width change (px) to trigger a full geometry recompute
+     * on resize. Smaller changes are ignored to avoid unnecessary recalculation.
+     */
+    private static readonly WIDTH_CHANGE_THRESHOLD_PX;
+    /**
+     * Debounce timer for deferring heavy mirror-div measurement on large
+     * content changes (paste, setValue with 2000+ lines).
+     */
+    private deferredUpdateTimer;
+    /**
+     * Cached content width used to detect width changes on resize so we
+     * can trigger a full geometry recompute (wrapping changes).
+     */
+    private cachedContentWidth;
+    /** Cached textarea scrollHeight for optimised autoResizeTextarea(). */
+    private lastTextareaHeight;
+    private inner;
+    /**
+     * OVERSCAN — extra lines rendered above and below the visible area.
+     * 8 gives a comfortable buffer for fast momentum scrolling; the span-recycling
+     * approach (no DOM teardown) means a larger overscan has negligible cost.
+     */
+    private readonly OVERSCAN;
+    private spanPool;
+    private poolStart;
+    private poolEnd;
+    /** Called after every pool rebuild — use to drive live status-bar stats. */
+    onViewportChange: ((stats: GutterStats) => void) | null;
+    constructor(gutter: HTMLElement, textarea: HTMLTextAreaElement);
+    /**
+     * Set the shared scroll wrapper element.
+     * Must be called before enable() so scroll events are bound to the wrapper.
+     */
+    setScrollElement(el: HTMLElement): void;
+    private buildInner;
+    private setupMirror;
+    private destroyMirror;
+    /**
+     * Copy font metrics from the textarea into the mirror div.
+     * Returns computed layout values, or null when layout is unavailable
+     * (e.g. jsdom / hidden element).
+     */
+    private syncMirror;
+    /**
+     * Return the number of visual rows occupied by `line`.
+     * Fast path: if the line clearly fits on one row (no wrap), return 1
+     * without touching the mirror div.  Only wrapping lines pay the
+     * mirror-div measurement cost.
+     */
+    private rowCount;
+    enable(): void;
+    disable(): void;
+    /**
+     * Refresh cached layout dimensions after the editor container is resized.
+     * Call this from a ResizeObserver on the editor pane or the scroll wrapper
+     * so that recyclePool() continues using accurate viewport dimensions
+     * without reading from the DOM on every scroll event.
+     *
+     * If the content width has changed (e.g. splitter drag, window resize),
+     * this triggers a full geometry recompute because wrapping may have changed.
+     */
+    notifyResize(): void;
+    /**
+     * Full recompute: called whenever the document content changes.
+     * Measures each line's visual height and rebuilds the geometry cache,
+     * then re-renders the visible viewport.
+     *
+     * For large documents (> LARGE_DOC_THRESHOLD lines), this uses fast
+     * character-width estimation instead of per-line mirror-div measurement.
+     * A deferred rAF pass can refine wrapping estimates if needed.
+     */
+    update(): void;
+    /**
+     * Deferred precision pass for large documents: uses the mirror div
+     * only for lines that likely wrap, then updates the geometry cache.
+     * Runs after a short delay so paste operations are not blocked.
+     */
+    private refineLargeDoc;
+    /**
+     * Auto-resize the textarea so its full content is visible (no internal
+     * scrollbar).  The shared scroll wrapper provides the single scrollbar
+     * for both gutter and textarea.
+     *
+     * Optimised: only resets height when the content has likely changed size,
+     * avoiding unnecessary layout thrashing on every keystroke.
+     */
+    autoResizeTextarea(): void;
+    /**
+     * Recycle the span pool for the current viewport.
+     * Called after content changes and synchronously on every scroll event.
+     */
+    private renderVisible;
+    /**
+     * Recycle the span pool for the new visible range.
+     *
+     * Spans are updated in-place (style.top + textContent) — zero DOM
+     * add/remove during scrolling.  This runs SYNCHRONOUSLY in the scroll
+     * handler and maintains 60fps even for 10,000+ line documents.
+     *
+     * With the unified scroll wrapper the gutter and textarea share the
+     * same scrollTop so no scroll-fraction mapping is needed.
+     */
+    private recyclePool;
+    /**
+     * Binary search: return the index of the logical line whose range
+     * contains or immediately precedes `offsetPx`.
+     */
+    private lineIndexAtOffset;
+    /**
+     * Scroll handler — fully synchronous, no rAF deferral needed.
+     *
+     * With the unified scroll wrapper, this simply reads scrollTop from
+     * the wrapper and recycles the span pool.  No transform writes are
+     * needed since both gutter and textarea scroll together naturally.
+     */
+    private onScroll;
+    private cancelScrollRaf;
+    /**
+     * Ensure the cursor's line is visible within the scroll wrapper.
+     * Call after input, keyup, or any operation that may move the cursor.
+     */
+    ensureCursorVisible(): void;
+    /**
+     * Return the content-space Y offset (px) for the given 0-indexed logical line.
+     * Used by the editor's jumpToLine() to scroll the textarea precisely.
+     */
+    getLineOffset(lineIndex: number): number;
+    /**
+     * Return a snapshot of the virtual renderer's current state.
+     * Useful for live status-bar displays.
+     */
+    getStats(): GutterStats;
+    /** Return the scroll wrapper element, if set. */
+    getScrollElement(): HTMLElement | null;
+    destroy(): void;
+}

package/dist/core/ui/ModeController.d.ts

@@ -0,0 +1,9 @@
+import { EditorMode } from '../types';
+export declare class ModeController {
+    private currentMode;
+    private root;
+    constructor(root: HTMLElement, initialMode?: EditorMode);
+    getMode(): EditorMode;
+    setMode(mode: EditorMode): void;
+    private applyMode;
+}

package/dist/core/ui/PreviewController.d.ts

@@ -0,0 +1,13 @@
+import { RendererConfig, ParserConfig } from '../types';
+export declare class PreviewController {
+    private renderer;
+    private contentEl;
+    private renderTimer;
+    private delay;
+    constructor(contentEl: HTMLElement, delay?: number);
+    setRenderers(renderers: RendererConfig[]): void;
+    setParsers(parsers: ParserConfig[]): void;
+    render(source: string): void;
+    renderImmediate(source: string): Promise<void>;
+    destroy(): void;
+}

package/dist/core/ui/ResponsiveController.d.ts

@@ -0,0 +1,30 @@
+/**
+ * ResponsiveController
+ *
+ * Watches the editor root element's width via ResizeObserver and applies
+ * `smdx-is-mobile` / `smdx-is-tablet` CSS classes so that responsive
+ * styles work correctly for embedded editors whose width is independent
+ * of the viewport width.
+ *
+ * Breakpoints (mirrors the CSS @media queries in mobile.css):
+ *   ≤ 640 px  → smdx-is-mobile
+ *   641–1024 px → smdx-is-tablet
+ *   > 1024 px → (no extra class)
+ */
+export declare class ResponsiveController {
+    private root;
+    private observer;
+    /** Breakpoint widths in pixels – must match mobile.css */
+    private static readonly MOBILE_BREAKPOINT;
+    private static readonly TABLET_BREAKPOINT;
+    constructor(root: HTMLElement);
+    /**
+     * Start observing. Call once after the editor root is in the DOM.
+     */
+    start(): void;
+    /**
+     * Stop observing and clean up.
+     */
+    destroy(): void;
+    private applyBreakpointClasses;
+}

package/dist/core/ui/SplitterController.d.ts

@@ -0,0 +1,31 @@
+export declare class SplitterController {
+    private splitter;
+    private left;
+    private right;
+    private container;
+    private isDragging;
+    private startX;
+    private startLeftWidth;
+    /** Percentage of container width to move per keyboard arrow press. */
+    private static readonly KEYBOARD_STEP_PERCENT;
+    /** Callback fired during drag so the editor can refresh line-number geometry. */
+    private onResizeCallback;
+    /** Throttle timer for resize callbacks during drag. */
+    private resizeRafId;
+    constructor(container: HTMLElement, left: HTMLElement, right: HTMLElement);
+    /** Set a callback to fire during drag (for refreshing line-number geometry). */
+    onResize(fn: () => void): void;
+    private onMouseDown;
+    private onMouseMove;
+    private onMouseUp;
+    private onTouchStart;
+    private onTouchMove;
+    private onTouchEnd;
+    private onKeyDown;
+    private startDrag;
+    private moveDrag;
+    private endDrag;
+    /** Throttled resize notification via rAF. */
+    private notifyResize;
+    destroy(): void;
+}

package/dist/core/ui/StatusBarController.d.ts

@@ -0,0 +1,16 @@
+import { EditorMode } from '../types';
+export interface StatusBarControllerOptions {
+    bar: HTMLElement;
+    wordCount: HTMLElement;
+    lineCount: HTMLElement;
+    charCount: HTMLElement;
+    modeSwitcher: HTMLElement;
+    onModeChange: (mode: EditorMode) => void;
+}
+export declare class StatusBarController {
+    private opts;
+    constructor(opts: StatusBarControllerOptions);
+    private buildModeSwitcher;
+    updateCounts(text: string): void;
+    updateActiveMode(mode: EditorMode): void;
+}

package/dist/core/ui/ThemeController.d.ts

@@ -0,0 +1,8 @@
+export declare class ThemeController {
+    private root;
+    private _isDark;
+    constructor(root: HTMLElement);
+    applyTheme(theme: Record<string, string>): void;
+    toggleDarkMode(dark?: boolean): void;
+    isDarkMode(): boolean;
+}

package/dist/core/ui/ToolbarController.d.ts

@@ -0,0 +1,10 @@
+import { ToolbarConfig, EditorAPI } from '../types';
+import { PluginManager } from '../plugins/PluginManager';
+import { EventEmitter } from '../events';
+export declare class ToolbarController {
+    private toolbar;
+    constructor(config: ToolbarConfig, pluginManager: PluginManager, editorApi: EditorAPI, events: EventEmitter);
+    render(container: HTMLElement): HTMLElement;
+    updateActiveStates(): void;
+    destroy(): void;
+}