@flogeez/angular-tiptap-editor 3.1.3 → 3.1.4

package/CHANGELOG.md

@@ -5,6 +5,15 @@ 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).
 
+## [3.1.4] - 2026-05-20
+
+### 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.
+
 ## [3.1.3] - 2026-04-27
 
 ### Added
@@ -85,6 +94,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Removal of Deprecated Aliases**: Definitive removal of legacy exported names (without the `Ate` prefix) that were deprecated in v2.2.0.
 - **Office Paste**: Updated `@intevation/tiptap-extension-office-paste` to `^0.1.2` for Tiptap v3 compatibility.
 
+## [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

package/README.md

@@ -1,7 +1,7 @@
 # Angular Tiptap Editor
 
 > [!IMPORTANT]
-> **^v3.0.0 uses Tiptap v3**. If you need to stay on Tiptap v2, please use version `^2.4.0`.
+> **^v3.0.0 uses Tiptap v3**. If you need to stay on Tiptap v2, please use version `^2.4.1`.
 
 A modern, customizable Angular rich-text editor, built with **Tiptap**.
 
@@ -22,8 +22,8 @@ Yet, I've worked to keep it fully customizable: you can easily configure the edi
 - 🌍 **Built-in i18n**: Support for English and French out of the box.
 - 📎 **Office-Ready**: Clean pasting from Word and Excel.
 - 🎨 **Highly Customizable**: Easily configure toolbars, bubble menus, and slash command items.
-
 - 🛠️ **Extensible**: Easily add custom Tiptap extensions and reactive state calculators.
+- 🧩 **Angular 18+ Support**: Uses Angular 18's signals and esbuild for optimal performance.
 
 ## 📦 Installation
 

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 });
+    }
+    ngAfterViewInit() {
+        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() {
+        const nativeElement = this.menuRef().nativeElement;
+        if (!nativeElement) {
+            return;
+        }
+        const ed = this.editor();
+        if (this.tippyInstance) {
+            this.tippyInstance.destroy();
+        }
+        this.tippyInstance = tippy(document.body, {
+            content: nativeElement,
+            trigger: "manual",
+            placement: "top-start",
+            theme: "ate-bubble-menu",
+            appendTo: () => 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 || document.body,
+                            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":"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","sourcesContent":["import {\n  Directive,\n  input,\n  viewChild,\n  ElementRef,\n  OnDestroy,\n  inject,\n  effect,\n  AfterViewInit,\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 AfterViewInit, 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  ngAfterViewInit() {\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    const nativeElement = this.menuRef().nativeElement;\n    if (!nativeElement) {return;}\n\n    const ed = this.editor();\n    if (this.tippyInstance) {\n      this.tippyInstance.destroy();\n    }\n\n    this.tippyInstance = tippy(document.body, {\n      content: nativeElement,\n      trigger: \"manual\",\n      placement: \"top-start\",\n      theme: \"ate-bubble-menu\",\n      appendTo: () => (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 as HTMLElement) || document.body,\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"]}

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

@@ -0,0 +1,137 @@
+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 Sub-Bubble Menus (Link, Color).
+ * These menus are "sub-menus" of the main bubble menu or triggered/anchored by specific UI elements.
+ */
+export class AteBaseSubBubbleMenu {
+    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;
+        // 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 = setTimeout(() => {
+                if (this.shouldShow()) {
+                    this.showTippy();
+                }
+                else {
+                    this.hideTippy();
+                }
+            }, 10);
+        };
+        // Reactive effect for menu updates (re-positioning)
+        effect(() => {
+            // Monitor editor state and specific sub-menu states
+            this.state();
+            this.onStateChange();
+            this.updateMenu();
+        }, { allowSignalWrites: true });
+    }
+    ngAfterViewInit() {
+        this.initTippy();
+    }
+    ngOnDestroy() {
+        if (this.updateTimeout) {
+            clearTimeout(this.updateTimeout);
+        }
+        if (this.tippyInstance) {
+            this.tippyInstance.destroy();
+            this.tippyInstance = null;
+        }
+    }
+    /**
+     * Initializes the Tippy instance with sub-menu defaults.
+     */
+    initTippy() {
+        const nativeElement = this.menuRef().nativeElement;
+        if (!nativeElement) {
+            return;
+        }
+        const ed = this.editor();
+        if (this.tippyInstance) {
+            this.tippyInstance.destroy();
+        }
+        this.tippyInstance = tippy(document.body, {
+            content: nativeElement,
+            trigger: "manual",
+            placement: "bottom-start",
+            theme: "ate-bubble-menu",
+            appendTo: () => ed?.options?.element || document.body,
+            interactive: true,
+            arrow: false,
+            offset: [0, 8],
+            hideOnClick: true,
+            plugins: [sticky],
+            sticky: false,
+            getReferenceClientRect: () => this.getSelectionRect(),
+            popperOptions: {
+                modifiers: [
+                    {
+                        name: "preventOverflow",
+                        options: {
+                            boundary: ed?.options?.element || document.body,
+                            padding: 8,
+                        },
+                    },
+                    {
+                        name: "flip",
+                        options: { fallbackPlacements: ["top-start", "bottom-end", "top-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) {
+            this.tippyInstance.setProps({ getReferenceClientRect: () => this.getSelectionRect() });
+            this.tippyInstance.show();
+        }
+    }
+    /**
+     * Helper to hide the Tippy instance.
+     */
+    hideTippy() {
+        this.tippyInstance?.hide();
+    }
+    /**
+     * 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: AteBaseSubBubbleMenu, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "18.2.14", type: AteBaseSubBubbleMenu, 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: AteBaseSubBubbleMenu, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ate-base-sub-bubble-menu.js","sourceRoot":"","sources":["../../../../../../../projects/angular-tiptap-editor/src/lib/components/bubble-menus/base/ate-base-sub-bubble-menu.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  input,\n  viewChild,\n  ElementRef,\n  OnDestroy,\n  inject,\n  effect,\n  AfterViewInit,\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 Sub-Bubble Menus (Link, Color).\n * These menus are \"sub-menus\" of the main bubble menu or triggered/anchored by specific UI elements.\n */\n@Directive()\nexport abstract class AteBaseSubBubbleMenu implements AfterViewInit, 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  // Reactive state alias for templates\n  readonly state = this.editorCommands.editorState;\n\n  constructor() {\n    // Reactive effect for menu updates (re-positioning)\n    effect(() => {\n      // Monitor editor state and specific sub-menu states\n      this.state();\n      this.onStateChange();\n\n      this.updateMenu();\n    }, { allowSignalWrites: true });\n  }\n\n  ngAfterViewInit() {\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 with sub-menu defaults.\n   */\n  protected initTippy() {\n    const nativeElement = this.menuRef().nativeElement;\n    if (!nativeElement) {return;}\n\n    const ed = this.editor();\n    if (this.tippyInstance) {\n      this.tippyInstance.destroy();\n    }\n\n    this.tippyInstance = tippy(document.body, {\n      content: nativeElement,\n      trigger: \"manual\",\n      placement: \"bottom-start\",\n      theme: \"ate-bubble-menu\",\n      appendTo: () => (ed?.options?.element as HTMLElement) || document.body,\n      interactive: true,\n      arrow: false,\n      offset: [0, 8],\n      hideOnClick: true,\n      plugins: [sticky],\n      sticky: false,\n      getReferenceClientRect: () => this.getSelectionRect(),\n      popperOptions: {\n        modifiers: [\n          {\n            name: \"preventOverflow\",\n            options: {\n              boundary: (ed?.options?.element as HTMLElement) || document.body,\n              padding: 8,\n            },\n          },\n          {\n            name: \"flip\",\n            options: { fallbackPlacements: [\"top-start\", \"bottom-end\", \"top-end\"] },\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    this.updateTimeout = setTimeout(() => {\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  protected showTippy() {\n    if (this.tippyInstance) {\n      this.tippyInstance.setProps({ getReferenceClientRect: () => this.getSelectionRect() });\n      this.tippyInstance.show();\n    }\n  }\n\n  /**\n   * Helper to hide the Tippy instance.\n   */\n  protected hideTippy() {\n    this.tippyInstance?.hide();\n  }\n\n  // --- Abstract methods & Hooks ---\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   * Hook to add reactive dependencies to the update cycle.\n   */\n  protected abstract onStateChange(): 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"]}