@flogeez/angular-tiptap-editor 2.3.0 → 2.4.1

package/CHANGELOG.md

@@ -5,6 +5,29 @@ All notable changes to `@flogeez/angular-tiptap-editor` will be documented in th
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html), with the exception that the major version is specifically aligned with the major version of [Tiptap](https://tiptap.dev).
 
+## [2.4.1] - 2026-05-19
+
+### Fixed
+
+- **Angular 18 Compatibility**: Reverted library APIs from Angular 19+ back to Angular 18 standards:
+  - Replaced `provideEnvironmentInitializer()` with `APP_INITIALIZER` in `provideAteEditor()` to prevent crashes on Angular 18 environments.
+  - Added `{ allowSignalWrites: true }` to all `effect()` blocks to fix signal write errors at runtime.
+  - Fixed TypeScript compiler and builder errors under TypeScript 5.4.
+
+## [2.4.0] - 2026-01-29
+
+### Added
+
+- **Seamless Angular Integration**: Drastically simplified editor setup and component registration.
+  - **Global Provider**: Added `provideAteEditor()` for automatic injector capture and application-wide configuration defaults.
+  - **Declarative Angular Nodes**: Support for registering Angular components directly within the `angularNodes` configuration property.
+  - **Exhaustive Configuration**: All editor inputs (extensions, options, state calculators) are now part of `AteEditorConfig` for centralized management.
+  - **Config Inheritance**: Intelligent merging of global, instance, and input-level configurations.
+
+### Fixed
+
+- **NodeView Stability**: Enhanced initialization and lifecycle management for embedded Angular components.
+
 ## [2.3.0] - 2026-01-28
 
 ### Added

package/README.md

@@ -1,13 +1,16 @@
 # Angular Tiptap Editor
 
-A modern, customizable rich-text editor for Angular applications, built with Tiptap and featuring complete internationalization support.
+A modern, customizable rich-text editor for Angular, built with Tiptap.
 
 [![NPM Version](https://img.shields.io/npm/v/@flogeez/angular-tiptap-editor?style=for-the-badge&logo=npm)](https://www.npmjs.com/package/@flogeez/angular-tiptap-editor) [![Demo](https://img.shields.io/badge/Demo-Live-brightgreen?style=for-the-badge&logo=google-chrome)](https://flogeez.github.io/angular-tiptap-editor/) [![Try it on StackBlitz](https://img.shields.io/badge/Try%20it-StackBlitz-blue?style=for-the-badge&logo=stackblitz)](https://stackblitz.com/edit/angular-tiptap-editor)
 
+Angular Tiptap Editor is a high-performance WYSIWYG editor engineered for the modern Angular ecosystem. Built on top of Tiptap and powered by a native **Signals** architecture, it features a polished, professional design that feels, I think, clean and modern out of the box.
+Yet, I've worked to keep it fully customizable: you can easily configure the editor, tweak the UI, or even embed your own Angular components as interactive nodes.
+
 ## 🚀 Features
 
 - **Modern Angular**: Built with Angular 18+ using Signals and modern patterns for peak performance.
-- **Full Rich Text Power**: Powered by Tiptap v2 with extensive formatting and block capabilities.
+- **Full Rich Text Power**: Powered by Tiptap with extensive formatting and block capabilities.
 - **Modern UX (Notion-like)**: Intuitive slash commands and bubble menus for a keyboard-first experience.
 - **Highly Customizable**: Easily configure toolbars, bubble menus, and slash command items.
 - **Signal-Based Reactivity**: Pure Signal architecture natively compatible with `ChangeDetectionStrategy.OnPush`.
@@ -16,6 +19,9 @@ A modern, customizable rich-text editor for Angular applications, built with Tip
 - **Built-in i18n**: English & French support with a reactive, extensible locale system.
 - **Word/Character Count**: Real-time statistics with proper pluralization support.
 - **Office-Ready**: Cleaned-up pasting from Microsoft Word and Excel to maintain layout integrity.
+- **Seamless Angular Integration**: Use a single `provideAteEditor()` to initialize the library and share a root injector across all nodes.
+- **Universal Component Embedding**: Embed _any_ Angular component (library or custom) directly into the editor as a TipTap node.
+- **Global Configuration**: Set application-wide defaults for themes, toolbars, and features with hierarchical inheritance.
 - **Service Driven**: Deep programmatic control via `AteEditorCommandsService` and isolated instances.
 - **A11y First**: Built with accessibility best practices and full keyboard navigation.
 
@@ -51,7 +57,7 @@ Add the required CSS to your `angular.json` file in the `styles` array:
   "styles": [
     ...
     "node_modules/@fontsource/material-symbols-outlined/index.css",
-    "node_modules/@flogeez/angular-tiptap-editor/src/lib/styles/index.css",
+    "node_modules/@flogeez/angular-tiptap-editor/styles/index.css",
     ...
   ]
 }
@@ -138,37 +144,7 @@ export class AdvancedComponent {
 }
 ```
 
-### 3. Registering Custom Extensions
-
-Easily extend the editor with any standard Tiptap extension or your own custom marks/nodes via the `tiptapExtensions` input.
-
-```typescript
-import { Component } from "@angular/core";
-import { AngularTiptapEditorComponent } from "@flogeez/angular-tiptap-editor";
-
-@Component({
-  selector: "app-custom-extensions",
-  standalone: true,
-  imports: [AngularTiptapEditorComponent],
-  template: `
-    <angular-tiptap-editor
-      [content]="content"
-      [tiptapExtensions]="extensions"
-      (contentChange)="content = $event" />
-  `,
-})
-export class CustomExtensionsComponent {
-  content = "<p>Custom extensions example</p>";
-
-  extensions = [
-    // Add your custom TipTap extensions here
-    // Example: Custom extension configuration
-    // MyCustomExtension.configure({ /* options */ })
-  ];
-}
-```
-
-### 4. With Form Integration
+### 3. With Form Integration
 
 ```typescript
 import { Component } from "@angular/core";
@@ -183,9 +159,7 @@ import { AngularTiptapEditorComponent } from "@flogeez/angular-tiptap-editor";
     <form>
       <angular-tiptap-editor
         [formControl]="contentControl"
-        placeholder="Enter your content here..."
-        [showCharacterCount]="true"
-        [showWordCount]="true" />
+        placeholder="Enter your content here..." />
       <button type="submit">Submit</button>
     </form>
   `,
@@ -195,25 +169,90 @@ export class FormComponent {
 }
 ```
 
-### 5. Using EditorCommandsService
+## ⚙️ Advanced Setup & Extensions
+
+### 1. Global Setup (Recommended)
+
+Initialize the library globally in your `app.config.ts` or `main.ts` to capture the root injector and set application-wide defaults.
+
+```typescript
+import { ApplicationConfig } from "@angular/core";
+import { provideAteEditor } from "@flogeez/angular-tiptap-editor";
+
+export const appConfig: ApplicationConfig = {
+  providers: [
+    provideAteEditor({
+      theme: "auto",
+      mode: "seamless",
+      tiptapExtensions: [
+        /* Global TipTap Extensions */
+      ],
+      stateCalculators: [
+        /* Global State Calculators */
+      ],
+    }),
+  ],
+};
+```
+
+### 2. Embedding Angular Components (Angular Nodes)
+
+Turn any Angular component into a TipTap node without writing extension code. This project makes it easy to map your existing Angular components directly to the editor's document structure.
+
+```typescript
+import { Component } from "@angular/core";
+import {
+  AngularTiptapEditorComponent,
+  AteEditorConfig,
+  AteAngularNode,
+} from "@flogeez/angular-tiptap-editor";
+import { MyCounterComponent } from "./my-counter.component";
+
+@Component({
+  selector: "app-custom-nodes",
+  standalone: true,
+  imports: [AngularTiptapEditorComponent],
+  template: ` <angular-tiptap-editor [config]="editorConfig" /> `,
+})
+export class CustomNodesComponent {
+  // Use AteAngularNode for explicit typing if needed
+  myNodes: AteAngularNode[] = [
+    {
+      component: MyCounterComponent,
+      name: "counter",
+      attributes: { count: { default: 0 } },
+      group: "block",
+      draggable: true,
+    },
+  ];
+
+  editorConfig: AteEditorConfig = {
+    angularNodes: this.myNodes,
+  };
+}
+```
+
+> **Note**: Your component can inherit from `AteAngularNodeView` to access the full TipTap API (`editor`, `node`, `updateAttributes`) via Signals!
+
+### 3. Using EditorCommandsService
+
+Deep programmatic control over any editor instance.
 
 ```typescript
 import { Component, inject } from "@angular/core";
 import { AteEditorCommandsService } from "@flogeez/angular-tiptap-editor";
+import { Editor } from "@tiptap/core";
 
 @Component({
   selector: "app-commands",
   standalone: true,
   template: `
-    <div>
-      <div class="controls">
-        <button (click)="clearContent()">Clear Content</button>
-        <button (click)="focusEditor()">Focus Editor</button>
-        <button (click)="setContent()">Set Content</button>
-      </div>
-
-      <angular-tiptap-editor (editorCreated)="onEditorCreated($event)" />
+    <div class="controls">
+      <button (click)="clearContent()">Clear</button>
+      <button (click)="focusEditor()">Focus</button>
+      <button (click)="setContent()">Set Content</button>
     </div>
+    <angular-tiptap-editor (editorCreated)="onEditorCreated($event)" />
   `,
 })
 export class CommandsComponent {
@@ -225,72 +264,87 @@ export class CommandsComponent {
   }
 
   clearContent() {
-    if (this.editor) {
-      this.editorCommandsService.clearContent(this.editor);
-    }
+    if (this.editor) this.editorCommandsService.clearContent(this.editor);
   }
 
   focusEditor() {
-    if (this.editor) {
-      this.editorCommandsService.focus(this.editor);
-    }
+    if (this.editor) this.editorCommandsService.focus(this.editor);
   }
 
   setContent() {
-    if (this.editor) {
-      this.editorCommandsService.setContent(this.editor, "<h1>New Content</h1>");
-    }
+    if (this.editor) this.editorCommandsService.setContent(this.editor, "<h1>New!</h1>");
   }
 }
 ```
 
-### 6. Extending Reactive Editor State
+### 4. Custom Tiptap Extensions (Low Level)
 
-The editor features a dual-layer state architecture: **Automatic Tracking** for simple extensions and **Custom Calculators** for advanced needs.
+Standard TipTap extensions can be passed via the `tiptapExtensions` property in your config.
+
+```typescript
+import { AteEditorConfig } from "@flogeez/angular-tiptap-editor";
+
+@Component({
+  template: ` <angular-tiptap-editor [config]="editorConfig" /> `,
+})
+export class CustomExtensionsComponent {
+  editorConfig: AteEditorConfig = {
+    tiptapExtensions: [
+      /* Standard TipTap extensions (Highlight, Link, etc.) */
+    ],
+  };
+}
+```
+
+### 5. Extending Reactive Editor State (Calculators)
+
+The editor features a dual-layer state architecture for maximum reactivity.
 
 #### A. Automatic Extension Tracking (Zero Config)
 
-Any TipTap **Mark** or **Node** you add to `tiptapExtensions` is automatically tracked by our `DiscoveryCalculator`. You don't need to write any extra code to make them reactive.
+Any TipTap **Mark** or **Node** you add to `tiptapExtensions` is automatically tracked. You don't need extra code to make them reactive.
 
-- **For Marks**: `state().marks.yourExtensionName` (boolean) and `state().can.toggleYourExtensionName` (boolean).
+- **For Marks**: `state().marks.yourExtensionName` (boolean).
 - **For Nodes**: `state().nodes.yourExtensionName` (boolean).
 
 #### B. Custom State Calculators (Advanced)
 
-If you need to extract complex data (like attributes, depth, or custom logic), you can provide a custom `StateCalculator`.
+Extract complex data (attributes, depth, custom logic) via specialized Calculators.
 
-1.  **Define a Calculator**:
+**1. Define a Calculator**:
 
 ```typescript
 import { AteStateCalculator } from "@flogeez/angular-tiptap-editor";
 
-// This function will be called on every editor update
-export const MyCustomCalculator: AteStateCalculator = editor => {
-  return {
-    custom: {
-      hasHighPriority: editor.isActive("priority"),
-      selectionDepth: editor.state.selection.$from.depth,
-      // Any data you need...
-    },
-  };
-};
+// Called on every editor update
+export const MyCustomCalculator: AteStateCalculator = editor => ({
+  custom: { selectionDepth: editor.state.selection.$from.depth },
+});
 ```
 
-2.  **Register it in the Template**:
+**2. Register in the Config**:
+
+```typescript
+import { AteEditorConfig } from "@flogeez/angular-tiptap-editor";
+
+editorConfig: AteEditorConfig = {
+  stateCalculators: [MyCustomCalculator],
+};
+```
 
 ```html
-<angular-tiptap-editor [stateCalculators]="[MyCustomCalculator]" />
+<angular-tiptap-editor [config]="editorConfig" />
 ```
 
-3.  **Consume it anywhere**:
+**3. Consume the State**:
 
 ```typescript
 @Component({ ... })
 export class MyToolbarComponent {
   private editorCommands = inject(AteEditorCommandsService);
 
-  // Access your custom data reactively!
-  isHighPriority = computed(() => this.editorCommands.editorState().custom?.hasHighPriority);
+  // Access your custom data reactively via Signals!
+  depth = computed(() => this.editorCommands.editorState().custom?.selectionDepth);
 }
 ```
 
@@ -676,20 +730,6 @@ The library exposes a reactive `editorState` signal via the `AteEditorCommandsSe
 
 Since it's built with Signals, your custom toolbar items or UI overlays will only re-render when the specific data they consume changes, making it extremely efficient for `OnPush` applications.
 
----
-
-### 🧩 Custom Tiptap Extensions
-
-You are not limited to the built-in extensions. Pass any Tiptap extension, mark, or node:
-
-```html
-<angular-tiptap-editor [tiptapExtensions]="[MyCustomExtension]" />
-```
-
-Any custom extension is automatically detected and its state (active/can) is added to the reactive `editorState` snapshot.
-
----
-
 ## 🏗️ Architecture
 
 ### Reactive State Management
@@ -776,9 +816,8 @@ Contributions are welcome! Please feel free to submit a Pull Request.
 
 ### Latest Updates
 
-- ✅ **Unified Configuration**: New unified `AteEditorConfig` system for cleaner, type-safe editor setup.
-- ✅ **Enhanced Image Upload**: Advanced image handling with custom upload handlers and auto-compression.
-- ✅ **Refactored Link Management**: Dedicated link bubble menu with smart UI anchoring and real-time URL sync.
+- ✅ **Seamless Integration**: Drastically simplified setup with `provideAteEditor()` and declarative `nodeViews`.
+- ✅ **Universal Component Engine**: Embed any Angular component as an editor node.
 
 ---
 

package/esm2022/flogeez-angular-tiptap-editor.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmxvZ2Vlei1hbmd1bGFyLXRpcHRhcC1lZGl0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRpcHRhcC1lZGl0b3Ivc3JjL2Zsb2dlZXotYW5ndWxhci10aXB0YXAtZWRpdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2022/lib/ate-editor.provider.mjs

@@ -0,0 +1,38 @@
+import { makeEnvironmentProviders, APP_INITIALIZER, Injector, } from "@angular/core";
+import { setGlobalInjector } from "./node-view/ate-injector.registry";
+import { ATE_GLOBAL_CONFIG } from "./config/ate-global-config.token";
+/**
+ * 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'
+ *     })
+ *   ]
+ * });
+ * ```
+ */
+export function provideAteEditor(config) {
+    return makeEnvironmentProviders([
+        {
+            provide: ATE_GLOBAL_CONFIG,
+            useValue: config || {},
+        },
+        {
+            provide: APP_INITIALIZER,
+            useFactory: (injector) => () => {
+                setGlobalInjector(injector);
+            },
+            deps: [Injector],
+            multi: true,
+        },
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/bubble-menus/base/ate-base-bubble-menu.mjs

@@ -0,0 +1,207 @@
+import { Directive, input, viewChild, inject, effect, } from "@angular/core";
+import tippy, { sticky } from "tippy.js";
+import { AteEditorCommandsService } from "../../../services/ate-editor-commands.service";
+import { AteI18nService } from "../../../services/ate-i18n.service";
+import * as i0 from "@angular/core";
+/**
+ * Base abstract class for all Bubble Menus (Text, Image, Table, Cell).
+ * Handles common logic for Tippy.js initialization, positioning, and visibility.
+ */
+export class AteBaseBubbleMenu {
+    constructor() {
+        this.i18nService = inject(AteI18nService);
+        this.editorCommands = inject(AteEditorCommandsService);
+        // Core Inputs
+        this.editor = input.required();
+        // Required viewChild for the menu container
+        this.menuRef = viewChild.required("menuRef");
+        // Internal State
+        this.tippyInstance = null;
+        this.updateTimeout = null;
+        // Toolbar interaction state (from centralized service)
+        this.isToolbarInteracting = this.editorCommands.isToolbarInteracting;
+        // Reactive state alias for templates
+        this.state = this.editorCommands.editorState;
+        /**
+         * Core logic to decide whether to show or hide the menu.
+         */
+        this.updateMenu = () => {
+            if (this.updateTimeout) {
+                clearTimeout(this.updateTimeout);
+            }
+            this.updateTimeout = window.setTimeout(() => {
+                const ed = this.editor();
+                if (!ed) {
+                    return;
+                }
+                // Hide when interacting with the main toolbar
+                if (this.isToolbarInteracting()) {
+                    this.hideTippy();
+                    return;
+                }
+                if (this.shouldShow()) {
+                    this.showTippy();
+                }
+                else {
+                    this.hideTippy();
+                }
+            }, 10);
+        };
+        // Effect to reactively update the menu when editor state
+        // or toolbar interaction changes.
+        effect(() => {
+            this.state();
+            this.isToolbarInteracting();
+            // Also react to link/color edit modes to hide when sub-menus activate
+            this.editorCommands.linkEditMode();
+            this.editorCommands.colorEditMode();
+            this.updateMenu();
+        }, { allowSignalWrites: true });
+    }
+    ngOnInit() {
+        this.initTippy();
+    }
+    ngOnDestroy() {
+        if (this.updateTimeout) {
+            clearTimeout(this.updateTimeout);
+        }
+        if (this.tippyInstance) {
+            this.tippyInstance.destroy();
+            this.tippyInstance = null;
+        }
+    }
+    /**
+     * Initializes the Tippy instance.
+     * Can be overridden for specific Tippy configurations.
+     */
+    initTippy() {
+        if (!this.menuRef()?.nativeElement) {
+            // Re-try if the view child is not yet available
+            setTimeout(() => this.initTippy(), 50);
+            return;
+        }
+        const ed = this.editor();
+        if (this.tippyInstance) {
+            this.tippyInstance.destroy();
+        }
+        this.tippyInstance = tippy(document.body, {
+            content: this.menuRef().nativeElement,
+            trigger: "manual",
+            placement: "top-start",
+            appendTo: () => (ed ? ed.options.element : document.body),
+            interactive: true,
+            hideOnClick: false,
+            arrow: false,
+            offset: [0, 8],
+            plugins: [sticky],
+            sticky: false,
+            getReferenceClientRect: () => this.getSelectionRect(),
+            popperOptions: {
+                modifiers: [
+                    {
+                        name: "preventOverflow",
+                        options: {
+                            boundary: this.editor().options.element,
+                            padding: 8,
+                        },
+                    },
+                    {
+                        name: "flip",
+                        options: {
+                            fallbackPlacements: ["bottom-start", "top-end", "bottom-end"],
+                        },
+                    },
+                ],
+            },
+            onShow: instance => this.onTippyShow(instance),
+            onHide: instance => this.onTippyHide(instance),
+        });
+        this.updateMenu();
+    }
+    /**
+     * Helper to show the Tippy instance with updated positioning.
+     */
+    showTippy() {
+        if (!this.tippyInstance) {
+            return;
+        }
+        // Update position before showing
+        this.tippyInstance.setProps({
+            getReferenceClientRect: () => this.getSelectionRect(),
+            sticky: "reference",
+        });
+        this.tippyInstance.show();
+    }
+    /**
+     * Helper to hide the Tippy instance.
+     */
+    hideTippy() {
+        if (this.tippyInstance) {
+            this.tippyInstance.setProps({ sticky: false });
+            this.tippyInstance.hide();
+        }
+    }
+    /**
+     * Common command handler for buttons in the menu.
+     */
+    onCommand(command, event) {
+        if (event) {
+            event.preventDefault();
+            event.stopPropagation();
+        }
+        const ed = this.editor();
+        if (ed) {
+            this.executeCommand(ed, command);
+            this.updateMenu();
+        }
+    }
+    /**
+     * Shared helper to get the bounding rect of the current selection.
+     * Uses a combination of native selection and ProseMirror coordinates.
+     */
+    getRectForSelection(ed) {
+        if (!ed) {
+            return new DOMRect(0, 0, 0, 0);
+        }
+        const { from, to, empty } = ed.state.selection;
+        if (empty) {
+            return new DOMRect(-9999, -9999, 0, 0);
+        }
+        // 1. Try native selection for multi-line accuracy
+        const selection = window.getSelection();
+        if (selection && selection.rangeCount > 0) {
+            const range = selection.getRangeAt(0);
+            const rect = range.getBoundingClientRect();
+            // Ensure the rect is valid and belongs to the editor
+            if (rect.width > 0 && rect.height > 0) {
+                return rect;
+            }
+        }
+        // 2. Fallback to Tiptap coordinates for precision (single line / edge cases)
+        const start = ed.view.coordsAtPos(from);
+        const end = ed.view.coordsAtPos(to);
+        const top = Math.min(start.top, end.top);
+        const bottom = Math.max(start.bottom, end.bottom);
+        const left = Math.min(start.left, end.left);
+        const right = Math.max(start.right, end.right);
+        return new DOMRect(left, top, right - left, bottom - top);
+    }
+    /**
+     * Optional hook called when Tippy is about to be shown.
+     */
+    onTippyShow(_instance) {
+        /* empty */
+    }
+    /**
+     * Optional hook called when Tippy is about to be hidden.
+     */
+    onTippyHide(_instance) {
+        /* empty */
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteBaseBubbleMenu, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "18.2.14", type: AteBaseBubbleMenu, inputs: { editor: { classPropertyName: "editor", publicName: "editor", isSignal: true, isRequired: true, transformFunction: null } }, viewQueries: [{ propertyName: "menuRef", first: true, predicate: ["menuRef"], descendants: true, isSignal: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteBaseBubbleMenu, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ate-base-bubble-menu.js","sourceRoot":"","sources":["../../../../../../../projects/angular-tiptap-editor/src/lib/components/bubble-menus/base/ate-base-bubble-menu.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,KAAK,EACL,SAAS,EAIT,MAAM,EACN,MAAM,GACP,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,EAA6B,MAAM,EAAE,MAAM,UAAU,CAAC;AAEpE,OAAO,EAAE,wBAAwB,EAAE,MAAM,+CAA+C,CAAC;AACzF,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;;AAEpE;;;GAGG;AAEH,MAAM,OAAgB,iBAAiB;IAoBrC;QAnBmB,gBAAW,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;QACrC,mBAAc,GAAG,MAAM,CAAC,wBAAwB,CAAC,CAAC;QAErE,cAAc;QACd,WAAM,GAAG,KAAK,CAAC,QAAQ,EAAU,CAAC;QAElC,4CAA4C;QAC5C,YAAO,GAAG,SAAS,CAAC,QAAQ,CAA6B,SAAS,CAAC,CAAC;QAEpE,iBAAiB;QACP,kBAAa,GAAyB,IAAI,CAAC;QAC3C,kBAAa,GAAkB,IAAI,CAAC;QAE9C,uDAAuD;QACpC,yBAAoB,GAAG,IAAI,CAAC,cAAc,CAAC,oBAAoB,CAAC;QAEnF,qCAAqC;QAC5B,UAAK,GAAG,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC;QAkFjD;;WAEG;QACH,eAAU,GAAG,GAAG,EAAE;YAChB,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;gBACvB,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACnC,CAAC;YAED,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;gBAC1C,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;gBACzB,IAAI,CAAC,EAAE,EAAE,CAAC;oBACR,OAAO;gBACT,CAAC;gBAED,8CAA8C;gBAC9C,IAAI,IAAI,CAAC,oBAAoB,EAAE,EAAE,CAAC;oBAChC,IAAI,CAAC,SAAS,EAAE,CAAC;oBACjB,OAAO;gBACT,CAAC;gBAED,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;oBACtB,IAAI,CAAC,SAAS,EAAE,CAAC;gBACnB,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,SAAS,EAAE,CAAC;gBACnB,CAAC;YACH,CAAC,EAAE,EAAE,CAAC,CAAC;QACT,CAAC,CAAC;QAzGA,yDAAyD;QACzD,kCAAkC;QAClC,MAAM,CAAC,GAAG,EAAE;YACV,IAAI,CAAC,KAAK,EAAE,CAAC;YACb,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5B,sEAAsE;YACtE,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC;YACnC,IAAI,CAAC,cAAc,CAAC,aAAa,EAAE,CAAC;YAEpC,IAAI,CAAC,UAAU,EAAE,CAAC;QACpB,CAAC,EAAE,EAAE,iBAAiB,EAAE,IAAI,EAAE,CAAC,CAAC;IAClC,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,SAAS,EAAE,CAAC;IACnB,CAAC;IAED,WAAW;QACT,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACnC,CAAC;QACD,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;YAC7B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC5B,CAAC;IACH,CAAC;IAED;;;OAGG;IACO,SAAS;QACjB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,aAAa,EAAE,CAAC;YACnC,gDAAgD;YAChD,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC;YACvC,OAAO;QACT,CAAC;QAED,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QACzB,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;QAC/B,CAAC;QAED,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,EAAE;YACxC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,aAAa;YACrC,OAAO,EAAE,QAAQ;YACjB,SAAS,EAAE,WAAW;YACtB,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAE,EAAE,CAAC,OAAO,CAAC,OAAuB,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC;YAC1E,WAAW,EAAE,IAAI;YACjB,WAAW,EAAE,KAAK;YAClB,KAAK,EAAE,KAAK;YACZ,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;YACd,OAAO,EAAE,CAAC,MAAM,CAAC;YACjB,MAAM,EAAE,KAAK;YACb,sBAAsB,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,gBAAgB,EAAE;YACrD,aAAa,EAAE;gBACb,SAAS,EAAE;oBACT;wBACE,IAAI,EAAE,iBAAiB;wBACvB,OAAO,EAAE;4BACP,QAAQ,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,OAAO;4BACvC,OAAO,EAAE,CAAC;yBACX;qBACF;oBACD;wBACE,IAAI,EAAE,MAAM;wBACZ,OAAO,EAAE;4BACP,kBAAkB,EAAE,CAAC,cAAc,EAAE,SAAS,EAAE,YAAY,CAAC;yBAC9D;qBACF;iBACF;aACF;YACD,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC;YAC9C,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC;SAC/C,CAAC,CAAC;QAEH,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC;IA8BD;;OAEG;IACH,SAAS;QACP,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,OAAO;QACT,CAAC;QAED,iCAAiC;QACjC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC;YAC1B,sBAAsB,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,gBAAgB,EAAE;YACrD,MAAM,EAAE,WAAW;SACpB,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;IAC5B,CAAC;IAED;;OAEG;IACH,SAAS;QACP,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;YAC/C,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;QAC5B,CAAC;IACH,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,OAAe,EAAE,KAAa;QACtC,IAAI,KAAK,EAAE,CAAC;YACV,KAAK,CAAC,cAAc,EAAE,CAAC;YACvB,KAAK,CAAC,eAAe,EAAE,CAAC;QAC1B,CAAC;QACD,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QACzB,IAAI,EAAE,EAAE,CAAC;YACP,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;YACjC,IAAI,CAAC,UAAU,EAAE,CAAC;QACpB,CAAC;IACH,CAAC;IAED;;;OAGG;IACO,mBAAmB,CAAC,EAAU;QACtC,IAAI,CAAC,EAAE,EAAE,CAAC;YACR,OAAO,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACjC,CAAC;QAED,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;QAC/C,IAAI,KAAK,EAAE,CAAC;YACV,OAAO,IAAI,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACzC,CAAC;QAED,kDAAkD;QAClD,MAAM,SAAS,GAAG,MAAM,CAAC,YAAY,EAAE,CAAC;QACxC,IAAI,SAAS,IAAI,SAAS,CAAC,UAAU,GAAG,CAAC,EAAE,CAAC;YAC1C,MAAM,KAAK,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YACtC,MAAM,IAAI,GAAG,KAAK,CAAC,qBAAqB,EAAE,CAAC;YAE3C,qDAAqD;YACrD,IAAI,IAAI,CAAC,KAAK,GAAG,CAAC,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACtC,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QAED,6EAA6E;QAC7E,MAAM,KAAK,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QACxC,MAAM,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;QAEpC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;QACzC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QAClD,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;QAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;QAE/C,OAAO,IAAI,OAAO,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,CAAC;IAC5D,CAAC;IAmBD;;OAEG;IACO,WAAW,CAAC,SAAwB;QAC5C,WAAW;IACb,CAAC;IAED;;OAEG;IACO,WAAW,CAAC,SAAwB;QAC5C,WAAW;IACb,CAAC;+GA5OmB,iBAAiB;mGAAjB,iBAAiB;;4FAAjB,iBAAiB;kBADtC,SAAS","sourcesContent":["import {\n  Directive,\n  input,\n  viewChild,\n  ElementRef,\n  OnInit,\n  OnDestroy,\n  inject,\n  effect,\n} from \"@angular/core\";\nimport tippy, { Instance as TippyInstance, sticky } from \"tippy.js\";\nimport { Editor } from \"@tiptap/core\";\nimport { AteEditorCommandsService } from \"../../../services/ate-editor-commands.service\";\nimport { AteI18nService } from \"../../../services/ate-i18n.service\";\n\n/**\n * Base abstract class for all Bubble Menus (Text, Image, Table, Cell).\n * Handles common logic for Tippy.js initialization, positioning, and visibility.\n */\n@Directive()\nexport abstract class AteBaseBubbleMenu implements OnInit, OnDestroy {\n  protected readonly i18nService = inject(AteI18nService);\n  protected readonly editorCommands = inject(AteEditorCommandsService);\n\n  // Core Inputs\n  editor = input.required<Editor>();\n\n  // Required viewChild for the menu container\n  menuRef = viewChild.required<ElementRef<HTMLDivElement>>(\"menuRef\");\n\n  // Internal State\n  protected tippyInstance: TippyInstance | null = null;\n  protected updateTimeout: number | null = null;\n\n  // Toolbar interaction state (from centralized service)\n  protected readonly isToolbarInteracting = this.editorCommands.isToolbarInteracting;\n\n  // Reactive state alias for templates\n  readonly state = this.editorCommands.editorState;\n\n  constructor() {\n    // Effect to reactively update the menu when editor state\n    // or toolbar interaction changes.\n    effect(() => {\n      this.state();\n      this.isToolbarInteracting();\n      // Also react to link/color edit modes to hide when sub-menus activate\n      this.editorCommands.linkEditMode();\n      this.editorCommands.colorEditMode();\n\n      this.updateMenu();\n    }, { allowSignalWrites: true });\n  }\n\n  ngOnInit() {\n    this.initTippy();\n  }\n\n  ngOnDestroy() {\n    if (this.updateTimeout) {\n      clearTimeout(this.updateTimeout);\n    }\n    if (this.tippyInstance) {\n      this.tippyInstance.destroy();\n      this.tippyInstance = null;\n    }\n  }\n\n  /**\n   * Initializes the Tippy instance.\n   * Can be overridden for specific Tippy configurations.\n   */\n  protected initTippy() {\n    if (!this.menuRef()?.nativeElement) {\n      // Re-try if the view child is not yet available\n      setTimeout(() => this.initTippy(), 50);\n      return;\n    }\n\n    const ed = this.editor();\n    if (this.tippyInstance) {\n      this.tippyInstance.destroy();\n    }\n\n    this.tippyInstance = tippy(document.body, {\n      content: this.menuRef().nativeElement,\n      trigger: \"manual\",\n      placement: \"top-start\",\n      appendTo: () => (ed ? (ed.options.element as HTMLElement) : document.body),\n      interactive: true,\n      hideOnClick: false,\n      arrow: false,\n      offset: [0, 8],\n      plugins: [sticky],\n      sticky: false,\n      getReferenceClientRect: () => this.getSelectionRect(),\n      popperOptions: {\n        modifiers: [\n          {\n            name: \"preventOverflow\",\n            options: {\n              boundary: this.editor().options.element,\n              padding: 8,\n            },\n          },\n          {\n            name: \"flip\",\n            options: {\n              fallbackPlacements: [\"bottom-start\", \"top-end\", \"bottom-end\"],\n            },\n          },\n        ],\n      },\n      onShow: instance => this.onTippyShow(instance),\n      onHide: instance => this.onTippyHide(instance),\n    });\n\n    this.updateMenu();\n  }\n\n  /**\n   * Core logic to decide whether to show or hide the menu.\n   */\n  updateMenu = () => {\n    if (this.updateTimeout) {\n      clearTimeout(this.updateTimeout);\n    }\n\n    this.updateTimeout = window.setTimeout(() => {\n      const ed = this.editor();\n      if (!ed) {\n        return;\n      }\n\n      // Hide when interacting with the main toolbar\n      if (this.isToolbarInteracting()) {\n        this.hideTippy();\n        return;\n      }\n\n      if (this.shouldShow()) {\n        this.showTippy();\n      } else {\n        this.hideTippy();\n      }\n    }, 10);\n  };\n\n  /**\n   * Helper to show the Tippy instance with updated positioning.\n   */\n  showTippy() {\n    if (!this.tippyInstance) {\n      return;\n    }\n\n    // Update position before showing\n    this.tippyInstance.setProps({\n      getReferenceClientRect: () => this.getSelectionRect(),\n      sticky: \"reference\",\n    });\n    this.tippyInstance.show();\n  }\n\n  /**\n   * Helper to hide the Tippy instance.\n   */\n  hideTippy() {\n    if (this.tippyInstance) {\n      this.tippyInstance.setProps({ sticky: false });\n      this.tippyInstance.hide();\n    }\n  }\n\n  /**\n   * Common command handler for buttons in the menu.\n   */\n  onCommand(command: string, event?: Event) {\n    if (event) {\n      event.preventDefault();\n      event.stopPropagation();\n    }\n    const ed = this.editor();\n    if (ed) {\n      this.executeCommand(ed, command);\n      this.updateMenu();\n    }\n  }\n\n  /**\n   * Shared helper to get the bounding rect of the current selection.\n   * Uses a combination of native selection and ProseMirror coordinates.\n   */\n  protected getRectForSelection(ed: Editor): DOMRect {\n    if (!ed) {\n      return new DOMRect(0, 0, 0, 0);\n    }\n\n    const { from, to, empty } = ed.state.selection;\n    if (empty) {\n      return new DOMRect(-9999, -9999, 0, 0);\n    }\n\n    // 1. Try native selection for multi-line accuracy\n    const selection = window.getSelection();\n    if (selection && selection.rangeCount > 0) {\n      const range = selection.getRangeAt(0);\n      const rect = range.getBoundingClientRect();\n\n      // Ensure the rect is valid and belongs to the editor\n      if (rect.width > 0 && rect.height > 0) {\n        return rect;\n      }\n    }\n\n    // 2. Fallback to Tiptap coordinates for precision (single line / edge cases)\n    const start = ed.view.coordsAtPos(from);\n    const end = ed.view.coordsAtPos(to);\n\n    const top = Math.min(start.top, end.top);\n    const bottom = Math.max(start.bottom, end.bottom);\n    const left = Math.min(start.left, end.left);\n    const right = Math.max(start.right, end.right);\n\n    return new DOMRect(left, top, right - left, bottom - top);\n  }\n\n  // --- Abstract methods to be implemented by sub-components ---\n\n  /**\n   * Returns the Rect representing the target for positioning the menu.\n   */\n  abstract getSelectionRect(): DOMRect;\n\n  /**\n   * Returns whether the menu should be displayed based on current state.\n   */\n  abstract shouldShow(): boolean;\n\n  /**\n   * Executes the given command on the editor.\n   */\n  protected abstract executeCommand(editor: Editor, command: string, ...args: unknown[]): void;\n\n  /**\n   * Optional hook called when Tippy is about to be shown.\n   */\n  protected onTippyShow(_instance: TippyInstance) {\n    /* empty */\n  }\n\n  /**\n   * Optional hook called when Tippy is about to be hidden.\n   */\n  protected onTippyHide(_instance: TippyInstance) {\n    /* empty */\n  }\n}\n"]}