@flogeez/angular-tiptap-editor 2.2.3 → 2.4.0

package/index.d.ts

@@ -1,8 +1,10 @@
 import * as _flogeez_angular_tiptap_editor from '@flogeez/angular-tiptap-editor';
-import { Editor, Node, Mark, Extension, EditorOptions, JSONContent } from '@tiptap/core';
+import { Editor, NodeConfig, Extension, Node as Node$2, Mark, EditorOptions, JSONContent } from '@tiptap/core';
 import * as _angular_core from '@angular/core';
-import { AfterViewInit, OnDestroy, ElementRef } from '@angular/core';
+import { Injector, Type, AfterViewInit, OnDestroy, ElementRef, EnvironmentProviders, InjectionToken, Signal } from '@angular/core';
 import { Observable } from 'rxjs';
+import { Node as Node$1 } from '@tiptap/pm/model';
+import { Decoration, EditorView, NodeView } from '@tiptap/pm/view';
 import { ControlValueAccessor } from '@angular/forms';
 
 type SupportedLocale = "en" | "fr" | (string & {});
@@ -782,6 +784,147 @@ declare const ATE_CELL_BUBBLE_MENU_KEYS: readonly ["mergeCells", "splitCell"];
 type AteCellBubbleMenuKey = (typeof ATE_CELL_BUBBLE_MENU_KEYS)[number];
 type AteCellBubbleMenuConfig = Partial<Record<AteCellBubbleMenuKey, boolean>>;
 
+/**
+ * Common options for rendering any Angular component as a TipTap NodeView
+ */
+interface AteComponentRenderOptions {
+    /**
+     * Angular injector to use for creating the component
+     */
+    injector: Injector;
+    /**
+     * Additional inputs to pass to the component
+     */
+    inputs?: Record<string, unknown>;
+    /**
+     * Custom wrapper element tag (default: 'div')
+     */
+    wrapperTag?: string;
+    /**
+     * CSS classes to add to the wrapper element
+     */
+    wrapperClass?: string;
+    /**
+     * Whether the node should be treated as an atom (not editable)
+     * Default: true
+     */
+    atom?: boolean;
+    /**
+     * Enables editable content for <ng-content>.
+     * If true, TipTap will treat the component's content as editable.
+     * @default false
+     */
+    editableContent?: boolean;
+    /**
+     * Optional CSS selector to target an internal element of the component as the editable area.
+     */
+    contentSelector?: string;
+    /**
+     * Type of content allowed in the editable area.
+     */
+    contentMode?: "block" | "inline";
+    /**
+     * Whether to ignore mutations in the component's DOM.
+     * If true, TipTap won't try to sync changes from the component's DOM back to the editor state.
+     * @default true
+     */
+    ignoreMutation?: boolean | ((mutation: MutationRecord | {
+        type: "selection";
+        target: Node;
+    }) => boolean);
+    /**
+     * Callback called when an Output event is emitted by the component.
+     */
+    onOutput?: (outputName: string, value: unknown) => void;
+    /**
+     * Callback called when the node is updated.
+     */
+    onUpdate?: (node: Node$1) => void;
+    /**
+     * Callback called when the component is destroyed.
+     */
+    onDestroy?: () => void;
+}
+/**
+ * Unified configuration for registering an Angular component as an interactive 'Angular Node'.
+ * This provides high-level options to map Angular component logic (inputs, outputs, lifestyle)
+ * directly to TipTap's document structure.
+ */
+interface RegisterAngularComponentOptions<T = unknown> {
+    /**
+     * The Angular component to register
+     */
+    component: Type<T>;
+    /**
+     * Unique name for the TipTap node
+     */
+    name?: string;
+    /**
+     * Default inputs (for standard components)
+     */
+    defaultInputs?: Record<string, unknown>;
+    /**
+     * TipTap attributes (for TipTap-aware components)
+     */
+    attributes?: Record<string, {
+        default?: unknown;
+        parseHTML?: (element: HTMLElement) => unknown;
+        renderHTML?: (attributes: Record<string, unknown>) => Record<string, unknown> | null;
+    }>;
+    /**
+     * CSS selector for the editable area inside the component
+     */
+    contentSelector?: string;
+    /**
+     * Content mode for the editable area
+     */
+    contentMode?: "block" | "inline";
+    /**
+     * Enable editable content via <ng-content> or contentSelector
+     * @default false
+     */
+    editableContent?: boolean;
+    /**
+     * Node group (block or inline)
+     * @default 'block'
+     */
+    group?: "block" | "inline";
+    /**
+     * Is the node draggable?
+     * @default true
+     */
+    draggable?: boolean;
+    /**
+     * Whether to ignore mutations in the component's DOM.
+     * @default true
+     */
+    ignoreMutation?: boolean | ((mutation: MutationRecord | {
+        type: "selection";
+        target: Node;
+    }) => boolean);
+    /**
+     * Custom HTML attributes for the wrapper
+     */
+    HTMLAttributes?: Record<string, unknown>;
+    /**
+     * Custom parseHTML rules
+     */
+    parseHTML?: NodeConfig["parseHTML"];
+    /**
+     * Custom renderHTML function
+     */
+    renderHTML?: NodeConfig["renderHTML"];
+    /**
+     * Callback called when an Output event is emitted by the component.
+     */
+    onOutput?: (outputName: string, value: unknown) => void;
+}
+
+/**
+ * Type representing an Angular component that can be registered as an editor node.
+ * Can be a direct Component class or a full registration options object.
+ */
+type AteAngularNode = Type<unknown> | RegisterAngularComponentOptions<unknown>;
 /**
  * Global configuration interface for Angular Tiptap Editor.
  * Uses a flat structure for common settings and objects for complex configurations.
@@ -851,6 +994,22 @@ interface AteEditorConfig {
     floatingToolbar?: boolean;
     /** Technical configuration for image uploads */
     imageUpload?: AteImageUploadConfig;
+    /**
+     * List of Angular components to automatically register as interactive editor nodes.
+     * This is the preferred way to extend the editor with custom Angular logic.
+     */
+    angularNodes?: AteAngularNode[];
+    /** Standard TipTap extensions (Nodes, Marks, or Plugins) */
+    tiptapExtensions?: (Extension | Node$2 | Mark)[];
+    /** Raw TipTap editor options (e.g., enableInputRules, injectCSS, etc.) */
+    tiptapOptions?: Partial<EditorOptions>;
+    /** Reactive state calculators to extend the editor's live state */
+    stateCalculators?: AteStateCalculator[];
+    /**
+     * Fully custom slash commands configuration.
+     * When provided, it replaces the default groups based on toolbar toggles.
+     */
+    customSlashCommands?: AteCustomSlashCommands;
 }
 
 /**
@@ -865,6 +1024,14 @@ declare class AteNoopValueAccessorDirective implements ControlValueAccessor {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AteNoopValueAccessorDirective, never, never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * The main rich-text editor component for Angular.
+ *
+ * Powered by Tiptap and built with a native Signal-based architecture, it provides
+ * a seamless, high-performance editing experience. Supports automatic registration
+ * of Angular components as interactive nodes ('Angular Nodes'), full Reactive Forms
+ * integration, and extensive customization via the AteEditorConfig.
+ */
 declare class AngularTiptapEditorComponent implements AfterViewInit, OnDestroy {
     /** Configuration globale de l'éditeur */
     config: _angular_core.InputSignal<AteEditorConfig>;
@@ -891,7 +1058,7 @@ declare class AngularTiptapEditorComponent implements AfterViewInit, OnDestroy {
     floatingToolbar: _angular_core.InputSignal<boolean>;
     showEditToggle: _angular_core.InputSignal<boolean>;
     spellcheck: _angular_core.InputSignal<boolean>;
-    tiptapExtensions: _angular_core.InputSignal<(Node<any, any> | Mark<any, any> | Extension<any, any>)[]>;
+    tiptapExtensions: _angular_core.InputSignal<(Node$2<any, any> | Mark<any, any> | Extension<any, any>)[]>;
     tiptapOptions: _angular_core.InputSignal<Partial<EditorOptions>>;
     showBubbleMenu: _angular_core.InputSignal<boolean>;
     bubbleMenu: _angular_core.InputSignal<Partial<AteBubbleMenuConfig>>;
@@ -989,6 +1156,10 @@ declare class AngularTiptapEditorComponent implements AfterViewInit, OnDestroy {
     readonly finalShowCharacterCount: _angular_core.Signal<boolean>;
     readonly finalShowWordCount: _angular_core.Signal<boolean>;
     readonly finalLocale: _angular_core.Signal<SupportedLocale>;
+    readonly finalTiptapExtensions: _angular_core.Signal<(Node$2<any, any> | Mark<any, any> | Extension<any, any>)[]>;
+    readonly finalTiptapOptions: _angular_core.Signal<Partial<EditorOptions>>;
+    readonly finalStateCalculators: _angular_core.Signal<AteStateCalculator[]>;
+    readonly finalAngularNodesConfig: _angular_core.Signal<_flogeez_angular_tiptap_editor.AteAngularNode[]>;
     readonly finalImageUploadConfig: _angular_core.Signal<{
         maxSize: number;
         handler?: AteImageUploadHandler;
@@ -1008,6 +1179,51 @@ declare class AngularTiptapEditorComponent implements AfterViewInit, OnDestroy {
     readonly i18nService: AteI18nService;
     readonly editorCommandsService: AteEditorCommandsService;
     readonly editorState: _angular_core.Signal<_flogeez_angular_tiptap_editor.EditorStateSnapshot>;
+    private injector;
+    private globalConfig;
+    /**
+     * Final merged configuration.
+     * Priority: Input [config] > Global config via provideAteEditor()
+     */
+    readonly effectiveConfig: _angular_core.Signal<{
+        theme?: "light" | "dark" | "auto";
+        mode?: "classic" | "seamless";
+        height?: string;
+        autofocus?: "start" | "end" | "all" | boolean | number;
+        placeholder?: string;
+        editable?: boolean;
+        minHeight?: string;
+        maxHeight?: string;
+        fillContainer?: boolean;
+        disabled?: boolean;
+        locale?: string;
+        spellcheck?: boolean;
+        enableOfficePaste?: boolean;
+        showToolbar?: boolean;
+        showFooter?: boolean;
+        showCharacterCount?: boolean;
+        showWordCount?: boolean;
+        showEditToggle?: boolean;
+        showBubbleMenu?: boolean;
+        showImageBubbleMenu?: boolean;
+        showTableMenu?: boolean;
+        showCellMenu?: boolean;
+        enableSlashCommands?: boolean;
+        maxCharacters?: number;
+        toolbar?: AteToolbarConfig;
+        bubbleMenu?: AteBubbleMenuConfig;
+        imageBubbleMenu?: AteImageBubbleMenuConfig;
+        tableBubbleMenu?: AteTableBubbleMenuConfig;
+        cellBubbleMenu?: AteCellBubbleMenuConfig;
+        slashCommands?: AteSlashCommandsConfig;
+        floatingToolbar?: boolean;
+        imageUpload?: _flogeez_angular_tiptap_editor.AteImageUploadConfig;
+        angularNodes?: _flogeez_angular_tiptap_editor.AteAngularNode[];
+        tiptapExtensions?: (Extension | Node$2 | Mark)[];
+        tiptapOptions?: Partial<EditorOptions>;
+        stateCalculators?: AteStateCalculator[];
+        customSlashCommands?: AteCustomSlashCommands;
+    }>;
     constructor();
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
@@ -1031,6 +1247,26 @@ declare class AngularTiptapEditorComponent implements AfterViewInit, OnDestroy {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<AngularTiptapEditorComponent, "angular-tiptap-editor", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "minHeight": { "alias": "minHeight"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "fillContainer": { "alias": "fillContainer"; "required": false; "isSignal": true; }; "showToolbar": { "alias": "showToolbar"; "required": false; "isSignal": true; }; "showFooter": { "alias": "showFooter"; "required": false; "isSignal": true; }; "showCharacterCount": { "alias": "showCharacterCount"; "required": false; "isSignal": true; }; "showWordCount": { "alias": "showWordCount"; "required": false; "isSignal": true; }; "maxCharacters": { "alias": "maxCharacters"; "required": false; "isSignal": true; }; "enableOfficePaste": { "alias": "enableOfficePaste"; "required": false; "isSignal": true; }; "enableSlashCommands": { "alias": "enableSlashCommands"; "required": false; "isSignal": true; }; "slashCommands": { "alias": "slashCommands"; "required": false; "isSignal": true; }; "customSlashCommands": { "alias": "customSlashCommands"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "autofocus": { "alias": "autofocus"; "required": false; "isSignal": true; }; "seamless": { "alias": "seamless"; "required": false; "isSignal": true; }; "floatingToolbar": { "alias": "floatingToolbar"; "required": false; "isSignal": true; }; "showEditToggle": { "alias": "showEditToggle"; "required": false; "isSignal": true; }; "spellcheck": { "alias": "spellcheck"; "required": false; "isSignal": true; }; "tiptapExtensions": { "alias": "tiptapExtensions"; "required": false; "isSignal": true; }; "tiptapOptions": { "alias": "tiptapOptions"; "required": false; "isSignal": true; }; "showBubbleMenu": { "alias": "showBubbleMenu"; "required": false; "isSignal": true; }; "bubbleMenu": { "alias": "bubbleMenu"; "required": false; "isSignal": true; }; "showImageBubbleMenu": { "alias": "showImageBubbleMenu"; "required": false; "isSignal": true; }; "imageBubbleMenu": { "alias": "imageBubbleMenu"; "required": false; "isSignal": true; }; "toolbar": { "alias": "toolbar"; "required": false; "isSignal": true; }; "showTableBubbleMenu": { "alias": "showTableBubbleMenu"; "required": false; "isSignal": true; }; "tableBubbleMenu": { "alias": "tableBubbleMenu"; "required": false; "isSignal": true; }; "showCellBubbleMenu": { "alias": "showCellBubbleMenu"; "required": false; "isSignal": true; }; "cellBubbleMenu": { "alias": "cellBubbleMenu"; "required": false; "isSignal": true; }; "stateCalculators": { "alias": "stateCalculators"; "required": false; "isSignal": true; }; "imageUpload": { "alias": "imageUpload"; "required": false; "isSignal": true; }; "imageUploadHandler": { "alias": "imageUploadHandler"; "required": false; "isSignal": true; }; }, { "contentChange": "contentChange"; "editorCreated": "editorCreated"; "editorUpdate": "editorUpdate"; "editorFocus": "editorFocus"; "editorBlur": "editorBlur"; "editableChange": "editableChange"; }, never, never, true, [{ directive: typeof AteNoopValueAccessorDirective; inputs: {}; outputs: {}; }]>;
 }
 
+/**
+ * Provides the necessary configuration and initialization for the Angular TipTap Editor.
+ * This should be called in your app.config.ts (for standalone) or main.ts.
+ *
+ * This provider is essential for 'Angular Nodes' to work correctly, as it captures the
+ * root Injector required to instantiate custom Angular components within the editor.
+ * @example
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideAteEditor({
+ *       theme: 'dark',
+ *       mode: 'seamless'
+ *     })
+ *   ]
+ * });
+ * ```
+ */
+declare function provideAteEditor(config?: AteEditorConfig): EnvironmentProviders;
+
 declare class AteImageService {
     /** Signals for image state */
     selectedImage: _angular_core.WritableSignal<AteImageData | null>;
@@ -1228,6 +1464,182 @@ declare const ATE_DEFAULT_IMAGE_BUBBLE_MENU_CONFIG: AteImageBubbleMenuConfig;
 declare const ATE_DEFAULT_TABLE_MENU_CONFIG: AteTableBubbleMenuConfig;
 declare const ATE_DEFAULT_CELL_MENU_CONFIG: AteCellBubbleMenuConfig;
 
+/**
+ * Injection Token for global editor configuration.
+ */
+declare const ATE_GLOBAL_CONFIG: InjectionToken<AteEditorConfig>;
+
+/**
+ * Props that are injected into Angular NodeView components
+ */
+interface AteAngularNodeViewProps {
+    editor: Editor;
+    node: Node$1;
+    decorations: readonly Decoration[];
+    selected: boolean;
+    extension: unknown;
+    getPos: () => number | undefined;
+    updateAttributes: (attrs: Record<string, unknown>) => void;
+    deleteNode: () => void;
+}
+/**
+ * Base abstract class for custom 'Angular Nodes'.
+ *
+ * Extend this class in your custom components to automatically receive TipTap editor
+ * properties (node attributes, selection state, etc.) as reactive Signals.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   selector: 'app-counter',
+ *   template: `
+ *     <div>
+ *       <button (click)="increment()">Count: {{ node().attrs['count'] }}</button>
+ *     </div>
+ *   `
+ * })
+ * export class CounterComponent extends AteAngularNodeView {
+ *   increment() {
+ *     const count = this.node().attrs['count'] || 0;
+ *     this.updateAttributes({ count: count + 1 });
+ *   }
+ * }
+ * ```
+ */
+declare abstract class AteAngularNodeView {
+    /**
+     * The TipTap editor instance
+     */
+    editor: Signal<Editor>;
+    /**
+     * The ProseMirror node
+     */
+    node: Signal<Node$1>;
+    /**
+     * Decorations applied to this node
+     */
+    decorations: Signal<readonly Decoration[]>;
+    /**
+     * Whether the node is currently selected
+     */
+    selected: Signal<boolean>;
+    /**
+     * The extension instance that created this node
+     */
+    extension: Signal<unknown>;
+    /**
+     * Function to get the current position of this node in the document
+     */
+    getPos: () => number | undefined;
+    /**
+     * Update the attributes of this node
+     *
+     * @param attrs - Partial attributes to update
+     *
+     * @example
+     * ```typescript
+     * this.updateAttributes({ count: 5, color: 'blue' });
+     * ```
+     */
+    updateAttributes: (attrs: Record<string, unknown>) => void;
+    /**
+     * Delete this node from the document
+     */
+    deleteNode: () => void;
+    /** @internal */
+    private _writableSignals?;
+    /**
+     * Internal method to initialize the component with NodeView props.
+     * This is called by the AngularNodeViewRenderer.
+     *
+     * @internal
+     */
+    _initNodeView(props: AteAngularNodeViewProps): void;
+    /**
+     * Internal method to update the component when the node changes.
+     * This is called by the AngularNodeViewRenderer.
+     *
+     * @internal
+     */
+    _updateNodeView(node: Node$1, decorations: readonly Decoration[]): void;
+    /**
+     * Internal method to update the selection state.
+     * This is called by the AngularNodeViewRenderer.
+     *
+     * @internal
+     */
+    _selectNodeView(): void;
+    /**
+     * Internal method to update the deselection state.
+     * This is called by the AngularNodeViewRenderer.
+     *
+     * @internal
+     */
+    _deselectNodeView(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AteAngularNodeView, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AteAngularNodeView, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Universal Renderer for Angular Components as TipTap NodeViews.
+ *
+ * Supports:
+ * - TipTap-Aware components (extending AteAngularNodeView)
+ * - Standard library components (automatic @Input() sync)
+ * - Signal-based inputs and outputs (Angular 18+)
+ * - Content projection (editableContent)
+ * - Unified lifecycle and event management
+ */
+declare function AteNodeViewRenderer<T>(component: Type<T>, options: AteComponentRenderOptions): (props: {
+    node: Node$1;
+    view: EditorView;
+    getPos: () => number | undefined;
+    decorations: readonly Decoration[];
+    editor: Editor;
+    extension: unknown;
+}) => NodeView;
+
+/**
+ * Factory to transform an Angular component into a TipTap Node extension.
+ * Supports both "TipTap-Aware" and "Standard" modes.
+ *
+ * @internal
+ */
+declare function createAngularComponentExtension<T = unknown>(injector: Injector, options: RegisterAngularComponentOptions<T>): Node$2;
+
+/**
+ * Registers ANY Angular component as a TipTap node extension.
+ *
+ * This function is the single public entry point for adding custom components.
+ * It supports two distinct modes:
+ *
+ * 1. **TipTap-Aware Mode** (the component extends `AteAngularNodeView`):
+ *    Grants direct access to the TipTap API (`editor`, `node`, `updateAttributes`, etc.) within the component.
+ *
+ * 2. **Standard Mode** (library or legacy components):
+ *    Allows using any existing Angular component. Its `@Input()` properties are automatically
+ *    synchronized with TipTap node attributes.
+ *
+ * @param injectorOrOptions - The Angular Injector OR the configuration options
+ * @param maybeOptions - Configuration options (if the first param was an injector)
+ * @returns A TipTap Node extension ready to be used
+ *
+ * @example
+ * ```typescript
+ * // Modern way (requires provideAteEditor())
+ * registerAngularComponent({
+ *   component: MyComponent,
+ *   name: 'myComponent'
+ * });
+ *
+ * // Classic way
+ * registerAngularComponent(injector, {
+ *   component: MyComponent
+ * });
+ * ```
+ */
+declare function registerAngularComponent<T = unknown>(injectorOrOptions: Injector | RegisterAngularComponentOptions<T>, maybeOptions?: RegisterAngularComponentOptions<T>): Node$2;
+
 /** @deprecated Renamed to `ATE_INITIAL_EDITOR_STATE`. This alias will be removed in v3.0.0. */
 declare const INITIAL_EDITOR_STATE: AteEditorStateSnapshot;
 
@@ -1259,5 +1671,5 @@ declare const DEFAULT_TABLE_MENU_CONFIG: Partial<Record<"addColumnBefore" | "add
 /** @deprecated Renamed to `ATE_DEFAULT_CELL_MENU_CONFIG`. This alias will be removed in v3.0.0. */
 declare const DEFAULT_CELL_MENU_CONFIG: Partial<Record<"mergeCells" | "splitCell", boolean>>;
 
-export { ATE_BUBBLE_MENU_KEYS, ATE_CELL_BUBBLE_MENU_KEYS, ATE_DEFAULT_BUBBLE_MENU_CONFIG, ATE_DEFAULT_CELL_MENU_CONFIG, ATE_DEFAULT_IMAGE_BUBBLE_MENU_CONFIG, ATE_DEFAULT_SLASH_COMMANDS_CONFIG, ATE_DEFAULT_TABLE_MENU_CONFIG, ATE_DEFAULT_TOOLBAR_CONFIG, ATE_IMAGE_BUBBLE_MENU_KEYS, ATE_INITIAL_EDITOR_STATE, ATE_SLASH_COMMAND_KEYS, ATE_TABLE_BUBBLE_MENU_KEYS, ATE_TOOLBAR_KEYS, AngularTiptapEditorComponent, AteColorPickerService, AteDiscoveryCalculator, AteEditorCommandsService, AteI18nService, AteImageCalculator, AteImageService, AteLinkService, AteMarksCalculator, AteNoopValueAccessorDirective, AteSelectionCalculator, AteStructureCalculator, AteTableCalculator, AteColorPickerService as ColorPickerService, DEFAULT_BUBBLE_MENU_CONFIG, DEFAULT_CELL_MENU_CONFIG, DEFAULT_IMAGE_BUBBLE_MENU_CONFIG, DEFAULT_SLASH_COMMANDS_CONFIG, DEFAULT_TABLE_MENU_CONFIG, DEFAULT_TOOLBAR_CONFIG, DiscoveryCalculator, AteEditorCommandsService as EditorCommandsService, INITIAL_EDITOR_STATE, ImageCalculator, AteImageService as ImageService, AteLinkService as LinkService, MarksCalculator, SLASH_COMMAND_KEYS, SelectionCalculator, StructureCalculator, TableCalculator, AteI18nService as TiptapI18nService, createDefaultSlashCommands, filterSlashCommands };
-export type { AteBubbleMenuConfig, AteBubbleMenuKey, AteCellBubbleMenuConfig, AteCellBubbleMenuKey, AteColorEditMode, AteColorPickerSelection, AteCustomBubbleMenuItem, AteCustomSlashCommands, AteCustomToolbarItem, AteEditorConfig, AteEditorStateSnapshot, AteImageBubbleMenuConfig, AteImageBubbleMenuKey, AteImageData, AteImageUploadConfig, AteImageUploadContext, AteImageUploadHandler, AteImageUploadHandlerResult, AteImageUploadOptions, AteImageUploadResult, AteResizeOptions, AteSlashCommandItem, AteSlashCommandKey, AteSlashCommandsConfig, AteStateCalculator, AteTableBubbleMenuConfig, AteTableBubbleMenuKey, AteToolbarConfig, AteToolbarKey, AteTranslations, AteBubbleMenuConfig as BubbleMenuConfig, AteCellBubbleMenuConfig as CellBubbleMenuConfig, AteCustomSlashCommands as CustomSlashCommands, AteEditorConfig as EditorConfig, AteEditorStateSnapshot as EditorStateSnapshot, AteImageBubbleMenuConfig as ImageBubbleMenuConfig, AteImageData as ImageData, AteImageUploadHandler as ImageUploadHandler, AteImageUploadOptions as ImageUploadOptions, AteImageUploadResult as ImageUploadResult, AteResizeOptions as ResizeOptions, AteSlashCommandItem as SlashCommandItem, AteSlashCommandKey as SlashCommandKey, AteSlashCommandsConfig as SlashCommandsConfig, SupportedLocale, AteTableBubbleMenuConfig as TableBubbleMenuConfig, AteToolbarConfig as ToolbarConfig };
+export { ATE_BUBBLE_MENU_KEYS, ATE_CELL_BUBBLE_MENU_KEYS, ATE_DEFAULT_BUBBLE_MENU_CONFIG, ATE_DEFAULT_CELL_MENU_CONFIG, ATE_DEFAULT_IMAGE_BUBBLE_MENU_CONFIG, ATE_DEFAULT_SLASH_COMMANDS_CONFIG, ATE_DEFAULT_TABLE_MENU_CONFIG, ATE_DEFAULT_TOOLBAR_CONFIG, ATE_GLOBAL_CONFIG, ATE_IMAGE_BUBBLE_MENU_KEYS, ATE_INITIAL_EDITOR_STATE, ATE_SLASH_COMMAND_KEYS, ATE_TABLE_BUBBLE_MENU_KEYS, ATE_TOOLBAR_KEYS, AngularTiptapEditorComponent, AteAngularNodeView, AteColorPickerService, AteDiscoveryCalculator, AteEditorCommandsService, AteI18nService, AteImageCalculator, AteImageService, AteLinkService, AteMarksCalculator, AteNodeViewRenderer, AteNoopValueAccessorDirective, AteSelectionCalculator, AteStructureCalculator, AteTableCalculator, AteColorPickerService as ColorPickerService, DEFAULT_BUBBLE_MENU_CONFIG, DEFAULT_CELL_MENU_CONFIG, DEFAULT_IMAGE_BUBBLE_MENU_CONFIG, DEFAULT_SLASH_COMMANDS_CONFIG, DEFAULT_TABLE_MENU_CONFIG, DEFAULT_TOOLBAR_CONFIG, DiscoveryCalculator, AteEditorCommandsService as EditorCommandsService, INITIAL_EDITOR_STATE, ImageCalculator, AteImageService as ImageService, AteLinkService as LinkService, MarksCalculator, SLASH_COMMAND_KEYS, SelectionCalculator, StructureCalculator, TableCalculator, AteI18nService as TiptapI18nService, createAngularComponentExtension, createDefaultSlashCommands, filterSlashCommands, provideAteEditor, registerAngularComponent };
+export type { AteAngularNode, AteBubbleMenuConfig, AteBubbleMenuKey, AteCellBubbleMenuConfig, AteCellBubbleMenuKey, AteColorEditMode, AteColorPickerSelection, AteComponentRenderOptions, AteCustomBubbleMenuItem, AteCustomSlashCommands, AteCustomToolbarItem, AteEditorConfig, AteEditorStateSnapshot, AteImageBubbleMenuConfig, AteImageBubbleMenuKey, AteImageData, AteImageUploadConfig, AteImageUploadContext, AteImageUploadHandler, AteImageUploadHandlerResult, AteImageUploadOptions, AteImageUploadResult, AteResizeOptions, AteSlashCommandItem, AteSlashCommandKey, AteSlashCommandsConfig, AteStateCalculator, AteTableBubbleMenuConfig, AteTableBubbleMenuKey, AteToolbarConfig, AteToolbarKey, AteTranslations, AteBubbleMenuConfig as BubbleMenuConfig, AteCellBubbleMenuConfig as CellBubbleMenuConfig, AteCustomSlashCommands as CustomSlashCommands, AteEditorConfig as EditorConfig, AteEditorStateSnapshot as EditorStateSnapshot, AteImageBubbleMenuConfig as ImageBubbleMenuConfig, AteImageData as ImageData, AteImageUploadHandler as ImageUploadHandler, AteImageUploadOptions as ImageUploadOptions, AteImageUploadResult as ImageUploadResult, RegisterAngularComponentOptions, AteResizeOptions as ResizeOptions, AteSlashCommandItem as SlashCommandItem, AteSlashCommandKey as SlashCommandKey, AteSlashCommandsConfig as SlashCommandsConfig, SupportedLocale, AteTableBubbleMenuConfig as TableBubbleMenuConfig, AteToolbarConfig as ToolbarConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flogeez/angular-tiptap-editor",
-  "version": "2.2.3",
+  "version": "2.4.0",
   "description": "A modern, customizable rich-text editor for Angular (18+), built with Tiptap and featuring complete internationalization support",
   "keywords": [
     "angular",