@flogeez/angular-tiptap-editor 3.1.3 → 3.1.4

package/esm2022/lib/components/slash-commands/ate-slash-commands.component.mjs

@@ -0,0 +1,328 @@
+import { Component, input, viewChild, effect, computed, inject, signal, ChangeDetectionStrategy, } from "@angular/core";
+import tippy, { sticky } from "tippy.js";
+import { AteI18nService } from "../../services/ate-i18n.service";
+import { AteEditorCommandsService } from "../../services/ate-editor-commands.service";
+import { createDefaultSlashCommands } from "../../config/ate-slash-commands.config";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import * as i0 from "@angular/core";
+// Default command definitions are now centralized in src/lib/config/slash-commands.config.ts
+export class AteSlashCommandsComponent {
+    constructor() {
+        this.i18nService = inject(AteI18nService);
+        this.editor = input.required();
+        this.config = input(undefined);
+        this.menuRef = viewChild.required("menuRef");
+        this.tippyInstance = null;
+        this.editorCommands = inject(AteEditorCommandsService);
+        // Local state
+        this.isActive = false;
+        this.currentQuery = signal("");
+        this.slashRange = null;
+        // Signal for selected index
+        this.selectedIndex = signal(0);
+        // Toolbar interaction state (from centralized service)
+        this.isToolbarInteracting = this.editorCommands.isToolbarInteracting;
+        this.commands = computed(() => {
+            const config = this.config();
+            if (config && config.commands) {
+                return config.commands;
+            }
+            // Fallback to default native commands
+            return createDefaultSlashCommands(this.i18nService, this.editorCommands);
+        });
+        this.filteredCommands = computed(() => {
+            const query = this.currentQuery().toLowerCase();
+            const commands = this.commands();
+            if (!query) {
+                return commands;
+            }
+            return commands.filter(command => command.title.toLowerCase().includes(query) ||
+                command.description.toLowerCase().includes(query) ||
+                command.keywords.some(keyword => keyword.toLowerCase().includes(query)));
+        });
+        this.updateMenu = () => {
+            const ed = this.editor();
+            if (!ed) {
+                return;
+            }
+            const { from } = ed.state.selection;
+            // Check if '/' was typed at the beginning of a line or after a space
+            const textBefore = ed.state.doc.textBetween(Math.max(0, from - 20), from, "\n");
+            const slashMatch = textBefore.match(/(?:^|\s)\/([^/\s]*)$/);
+            if (slashMatch) {
+                const query = slashMatch[1] || "";
+                const wasActive = this.isActive;
+                this.currentQuery.set(query);
+                this.slashRange = {
+                    from: from - slashMatch[0].length + slashMatch[0].indexOf("/"),
+                    to: from,
+                };
+                // Reset index if menu just became active
+                if (!wasActive) {
+                    this.selectedIndex.set(0);
+                }
+                this.isActive = true;
+                if (this.isToolbarInteracting()) {
+                    this.hideTippy();
+                }
+                else {
+                    this.showTippy();
+                }
+            }
+            else {
+                this.isActive = false;
+                this.hideTippy();
+            }
+        };
+        this.handleBlur = () => {
+            setTimeout(() => this.hideTippy(), 100);
+        };
+        effect(() => {
+            const ed = this.editor();
+            if (!ed) {
+                return;
+            }
+            // Clean up old listeners
+            ed.off("selectionUpdate", this.updateMenu);
+            ed.off("transaction", this.updateMenu);
+            ed.off("focus", this.updateMenu);
+            ed.off("blur", this.handleBlur);
+            // Add new listeners
+            ed.on("selectionUpdate", this.updateMenu);
+            ed.on("transaction", this.updateMenu);
+            ed.on("focus", this.updateMenu);
+            ed.on("blur", this.handleBlur);
+            // Use ProseMirror plugin system to intercept keys
+            this.addKeyboardPlugin(ed);
+            // updateMenu() will be called automatically when editor is ready
+        }, { allowSignalWrites: true });
+    }
+    ngAfterViewInit() {
+        this.initTippy();
+    }
+    ngOnDestroy() {
+        const ed = this.editor();
+        if (ed) {
+            ed.off("selectionUpdate", this.updateMenu);
+            ed.off("transaction", this.updateMenu);
+            ed.off("focus", this.updateMenu);
+            ed.off("blur", this.handleBlur);
+        }
+        if (this.tippyInstance) {
+            this.tippyInstance.destroy();
+            this.tippyInstance = null;
+        }
+    }
+    initTippy() {
+        const nativeElement = this.menuRef().nativeElement;
+        if (!nativeElement) {
+            return;
+        }
+        if (this.tippyInstance) {
+            this.tippyInstance.destroy();
+        }
+        this.tippyInstance = tippy(document.body, {
+            content: nativeElement,
+            trigger: "manual",
+            placement: "bottom-start",
+            theme: "slash-menu",
+            appendTo: _ref => {
+                // Always try to climb up to editor host to inherit CSS variables
+                const host = this.editor().options.element.closest("angular-tiptap-editor");
+                return host || document.body;
+            },
+            interactive: true,
+            arrow: false,
+            offset: [0, 8],
+            hideOnClick: true,
+            plugins: [sticky],
+            sticky: false,
+            getReferenceClientRect: () => this.getSlashRect(),
+            // Improve positioning with scroll
+            popperOptions: {
+                modifiers: [
+                    {
+                        name: "preventOverflow",
+                        options: {
+                            boundary: this.editor().options.element || document.body,
+                            padding: 8,
+                        },
+                    },
+                    {
+                        name: "flip",
+                        options: {
+                            fallbackPlacements: ["top-start", "bottom-end", "top-end"],
+                        },
+                    },
+                    {
+                        name: "hide",
+                    },
+                ],
+            },
+        });
+        // Initial check after Tippy is initialized
+        this.updateMenu();
+    }
+    getSlashRect() {
+        const ed = this.editor();
+        if (!ed || !this.slashRange) {
+            return new DOMRect(-9999, -9999, 0, 0);
+        }
+        try {
+            // Use ProseMirror coordinates for better precision
+            const coords = ed.view.coordsAtPos(this.slashRange.from);
+            return new DOMRect(coords.left, coords.top, 0, coords.bottom - coords.top);
+        }
+        catch (error) {
+            console.warn("Error calculating coordinates:", error);
+            // Fallback to window.getSelection
+            const selection = window.getSelection();
+            if (!selection || selection.rangeCount === 0) {
+                return new DOMRect(-9999, -9999, 0, 0);
+            }
+            const range = selection.getRangeAt(0);
+            return range.getBoundingClientRect();
+        }
+    }
+    scrollToSelected() {
+        // Scroll to the selected element
+        const menuEl = this.menuRef()?.nativeElement;
+        if (menuEl) {
+            const selectedItem = menuEl.querySelector(".slash-command-item.selected");
+            if (selectedItem) {
+                selectedItem.scrollIntoView({ block: "nearest", behavior: "smooth" });
+            }
+        }
+    }
+    showTippy() {
+        if (this.tippyInstance && this.filteredCommands().length > 0) {
+            this.tippyInstance.setProps({ sticky: "reference" });
+            this.tippyInstance.show();
+        }
+    }
+    hideTippy() {
+        if (this.tippyInstance) {
+            this.tippyInstance.setProps({ sticky: false });
+            this.tippyInstance.hide();
+        }
+    }
+    executeCommand(command) {
+        const ed = this.editor();
+        if (!ed || !this.slashRange) {
+            return;
+        }
+        // Remove slash text ("/")
+        const { tr } = ed.state;
+        tr.delete(this.slashRange.from, this.slashRange.to);
+        ed.view.dispatch(tr);
+        // Hide menu immediately
+        this.hideTippy();
+        this.isActive = false;
+        // Give focus back to editor and execute command
+        // Use a micro-delay to ensure ProseMirror DOM is stable after removing "/"
+        setTimeout(() => {
+            ed.commands.focus();
+            command.command(ed);
+        }, 10);
+    }
+    addKeyboardPlugin(ed) {
+        // Add a ProseMirror plugin to intercept keyboard events
+        const keyboardPlugin = new Plugin({
+            key: new PluginKey("slash-commands-keyboard"),
+            props: {
+                handleKeyDown: (view, event) => {
+                    // Only handle if menu is active
+                    if (!this.isActive || this.filteredCommands().length === 0) {
+                        return false;
+                    }
+                    switch (event.key) {
+                        case "ArrowDown": {
+                            event.preventDefault();
+                            const nextIndex = (this.selectedIndex() + 1) % this.filteredCommands().length;
+                            this.selectedIndex.set(nextIndex);
+                            this.scrollToSelected();
+                            return true;
+                        }
+                        case "ArrowUp": {
+                            event.preventDefault();
+                            const prevIndex = this.selectedIndex() === 0
+                                ? this.filteredCommands().length - 1
+                                : this.selectedIndex() - 1;
+                            this.selectedIndex.set(prevIndex);
+                            this.scrollToSelected();
+                            return true;
+                        }
+                        case "Enter": {
+                            event.preventDefault();
+                            const selectedCommand = this.filteredCommands()[this.selectedIndex()];
+                            if (selectedCommand) {
+                                this.executeCommand(selectedCommand);
+                            }
+                            return true;
+                        }
+                        case "Escape": {
+                            event.preventDefault();
+                            this.isActive = false;
+                            this.hideTippy();
+                            // Remove typed "/"
+                            if (this.slashRange) {
+                                const { tr } = view.state;
+                                tr.delete(this.slashRange.from, this.slashRange.to);
+                                view.dispatch(tr);
+                            }
+                            return true;
+                        }
+                    }
+                    return false;
+                },
+            },
+        });
+        // Add plugin to editor
+        ed.view.updateState(ed.view.state.reconfigure({
+            plugins: [keyboardPlugin, ...ed.view.state.plugins],
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteSlashCommandsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: AteSlashCommandsComponent, isStandalone: true, selector: "ate-slash-commands", inputs: { editor: { classPropertyName: "editor", publicName: "editor", isSignal: true, isRequired: true, transformFunction: null }, config: { classPropertyName: "config", publicName: "config", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "menuRef", first: true, predicate: ["menuRef"], descendants: true, isSignal: true }], ngImport: i0, template: `
+    <div #menuRef class="slash-commands-menu">
+      @for (command of filteredCommands(); track command.title) {
+        <div
+          class="slash-command-item"
+          [class.selected]="$index === selectedIndex()"
+          (mousedown)="executeCommand(command); $event.preventDefault(); $event.stopPropagation()"
+          (mouseenter)="selectedIndex.set($index)">
+          <div class="slash-command-icon">
+            <span class="material-symbols-outlined">{{ command.icon }}</span>
+          </div>
+          <div class="slash-command-content">
+            <div class="slash-command-title">{{ command.title }}</div>
+            <div class="slash-command-description">{{ command.description }}</div>
+          </div>
+        </div>
+      }
+    </div>
+  `, isInline: true, styles: [".slash-commands-menu{background:var(--ate-menu-bg);border:1px solid var(--ate-menu-border);border-radius:var(--ate-menu-border-radius, 12px);box-shadow:var(--ate-menu-shadow);padding:var(--ate-menu-padding);max-height:320px;overflow-y:auto;min-width:280px;outline:none;animation:slashMenuFadeIn .2s cubic-bezier(0,0,.2,1);scrollbar-width:thin;scrollbar-color:var(--ate-scrollbar-thumb) var(--ate-scrollbar-track)}.slash-commands-menu::-webkit-scrollbar{width:var(--ate-scrollbar-width)}.slash-commands-menu::-webkit-scrollbar-track{background:var(--ate-scrollbar-track)}.slash-commands-menu::-webkit-scrollbar-thumb{background:var(--ate-scrollbar-thumb);border:3px solid transparent;background-clip:content-box;border-radius:10px}.slash-commands-menu::-webkit-scrollbar-thumb:hover{background:var(--ate-scrollbar-thumb-hover);background-clip:content-box}@keyframes slashMenuFadeIn{0%{opacity:0;transform:translateY(4px)}to{opacity:1;transform:translateY(0)}}.slash-command-item{display:flex;align-items:center;gap:12px;padding:var(--ate-menu-padding);border-radius:var(--ate-menu-border-radius, 8px);cursor:pointer;transition:all .15s ease;border:var(--ate-border-width, 1px) solid transparent;outline:none;margin-bottom:2px}.slash-command-item:last-child{margin-bottom:0}.slash-command-item:hover{background:var(--ate-surface-secondary)}.slash-command-item.selected{background:var(--ate-primary-light);border-color:var(--ate-primary-light-alpha)}.slash-command-icon{display:flex;align-items:center;justify-content:center;width:32px;height:32px;background:var(--ate-surface-tertiary);border-radius:var(--ate-sub-border-radius, 8px);color:var(--ate-primary);flex-shrink:0;transition:all .15s ease}.slash-command-item.selected .slash-command-icon{background:var(--ate-primary);color:var(--ate-primary-contrast, #ffffff)}.slash-command-icon .material-symbols-outlined{font-size:18px}.slash-command-content{flex:1;min-width:0}.slash-command-title{font-weight:500;color:var(--ate-text);font-size:14px;margin-bottom:1px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.slash-command-description{color:var(--ate-text-secondary);font-size:11px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteSlashCommandsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "ate-slash-commands", standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div #menuRef class="slash-commands-menu">
+      @for (command of filteredCommands(); track command.title) {
+        <div
+          class="slash-command-item"
+          [class.selected]="$index === selectedIndex()"
+          (mousedown)="executeCommand(command); $event.preventDefault(); $event.stopPropagation()"
+          (mouseenter)="selectedIndex.set($index)">
+          <div class="slash-command-icon">
+            <span class="material-symbols-outlined">{{ command.icon }}</span>
+          </div>
+          <div class="slash-command-content">
+            <div class="slash-command-title">{{ command.title }}</div>
+            <div class="slash-command-description">{{ command.description }}</div>
+          </div>
+        </div>
+      }
+    </div>
+  `, styles: [".slash-commands-menu{background:var(--ate-menu-bg);border:1px solid var(--ate-menu-border);border-radius:var(--ate-menu-border-radius, 12px);box-shadow:var(--ate-menu-shadow);padding:var(--ate-menu-padding);max-height:320px;overflow-y:auto;min-width:280px;outline:none;animation:slashMenuFadeIn .2s cubic-bezier(0,0,.2,1);scrollbar-width:thin;scrollbar-color:var(--ate-scrollbar-thumb) var(--ate-scrollbar-track)}.slash-commands-menu::-webkit-scrollbar{width:var(--ate-scrollbar-width)}.slash-commands-menu::-webkit-scrollbar-track{background:var(--ate-scrollbar-track)}.slash-commands-menu::-webkit-scrollbar-thumb{background:var(--ate-scrollbar-thumb);border:3px solid transparent;background-clip:content-box;border-radius:10px}.slash-commands-menu::-webkit-scrollbar-thumb:hover{background:var(--ate-scrollbar-thumb-hover);background-clip:content-box}@keyframes slashMenuFadeIn{0%{opacity:0;transform:translateY(4px)}to{opacity:1;transform:translateY(0)}}.slash-command-item{display:flex;align-items:center;gap:12px;padding:var(--ate-menu-padding);border-radius:var(--ate-menu-border-radius, 8px);cursor:pointer;transition:all .15s ease;border:var(--ate-border-width, 1px) solid transparent;outline:none;margin-bottom:2px}.slash-command-item:last-child{margin-bottom:0}.slash-command-item:hover{background:var(--ate-surface-secondary)}.slash-command-item.selected{background:var(--ate-primary-light);border-color:var(--ate-primary-light-alpha)}.slash-command-icon{display:flex;align-items:center;justify-content:center;width:32px;height:32px;background:var(--ate-surface-tertiary);border-radius:var(--ate-sub-border-radius, 8px);color:var(--ate-primary);flex-shrink:0;transition:all .15s ease}.slash-command-item.selected .slash-command-icon{background:var(--ate-primary);color:var(--ate-primary-contrast, #ffffff)}.slash-command-icon .material-symbols-outlined{font-size:18px}.slash-command-content{flex:1;min-width:0}.slash-command-title{font-weight:500;color:var(--ate-text);font-size:14px;margin-bottom:1px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.slash-command-description{color:var(--ate-text-secondary);font-size:11px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}\n"] }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ate-slash-commands.component.js","sourceRoot":"","sources":["../../../../../../projects/angular-tiptap-editor/src/lib/components/slash-commands/ate-slash-commands.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  input,\n  viewChild,\n  ElementRef,\n  OnDestroy,\n  effect,\n  computed,\n  inject,\n  signal,\n  ChangeDetectionStrategy,\n  AfterViewInit,\n} from \"@angular/core\";\nimport tippy, { Instance as TippyInstance, sticky } from \"tippy.js\";\nimport { Editor } from \"@tiptap/core\";\nimport { AteI18nService } from \"../../services/ate-i18n.service\";\nimport { AteEditorCommandsService } from \"../../services/ate-editor-commands.service\";\nimport { createDefaultSlashCommands } from \"../../config/ate-slash-commands.config\";\nimport { AteSlashCommandItem, AteCustomSlashCommands } from \"../../models/ate-slash-command.model\";\nimport { Plugin, PluginKey } from \"@tiptap/pm/state\";\nimport { EditorView } from \"@tiptap/pm/view\";\n\n// Default command definitions are now centralized in src/lib/config/slash-commands.config.ts\n\n@Component({\n  selector: \"ate-slash-commands\",\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div #menuRef class=\"slash-commands-menu\">\n      @for (command of filteredCommands(); track command.title) {\n        <div\n          class=\"slash-command-item\"\n          [class.selected]=\"$index === selectedIndex()\"\n          (mousedown)=\"executeCommand(command); $event.preventDefault(); $event.stopPropagation()\"\n          (mouseenter)=\"selectedIndex.set($index)\">\n          <div class=\"slash-command-icon\">\n            <span class=\"material-symbols-outlined\">{{ command.icon }}</span>\n          </div>\n          <div class=\"slash-command-content\">\n            <div class=\"slash-command-title\">{{ command.title }}</div>\n            <div class=\"slash-command-description\">{{ command.description }}</div>\n          </div>\n        </div>\n      }\n    </div>\n  `,\n  styles: [\n    `\n      .slash-commands-menu {\n        background: var(--ate-menu-bg);\n        border: 1px solid var(--ate-menu-border);\n        border-radius: var(--ate-menu-border-radius, 12px);\n        box-shadow: var(--ate-menu-shadow);\n        padding: var(--ate-menu-padding);\n        max-height: 320px;\n        overflow-y: auto;\n        min-width: 280px;\n        outline: none;\n        animation: slashMenuFadeIn 0.2s cubic-bezier(0, 0, 0.2, 1);\n        scrollbar-width: thin;\n        scrollbar-color: var(--ate-scrollbar-thumb) var(--ate-scrollbar-track);\n      }\n\n      .slash-commands-menu::-webkit-scrollbar {\n        width: var(--ate-scrollbar-width);\n      }\n\n      .slash-commands-menu::-webkit-scrollbar-track {\n        background: var(--ate-scrollbar-track);\n      }\n\n      .slash-commands-menu::-webkit-scrollbar-thumb {\n        background: var(--ate-scrollbar-thumb);\n        border: 3px solid transparent;\n        background-clip: content-box;\n        border-radius: 10px;\n      }\n\n      .slash-commands-menu::-webkit-scrollbar-thumb:hover {\n        background: var(--ate-scrollbar-thumb-hover);\n        background-clip: content-box;\n      }\n\n      @keyframes slashMenuFadeIn {\n        from {\n          opacity: 0;\n          transform: translateY(4px);\n        }\n        to {\n          opacity: 1;\n          transform: translateY(0);\n        }\n      }\n\n      .slash-command-item {\n        display: flex;\n        align-items: center;\n        gap: 12px;\n        padding: var(--ate-menu-padding);\n        border-radius: var(--ate-menu-border-radius, 8px);\n        cursor: pointer;\n        transition: all 0.15s ease;\n        border: var(--ate-border-width, 1px) solid transparent;\n        outline: none;\n        margin-bottom: 2px;\n      }\n\n      .slash-command-item:last-child {\n        margin-bottom: 0;\n      }\n\n      .slash-command-item:hover {\n        background: var(--ate-surface-secondary);\n      }\n\n      .slash-command-item.selected {\n        background: var(--ate-primary-light);\n        border-color: var(--ate-primary-light-alpha);\n      }\n\n      .slash-command-icon {\n        display: flex;\n        align-items: center;\n        justify-content: center;\n        width: 32px;\n        height: 32px;\n        background: var(--ate-surface-tertiary);\n        border-radius: var(--ate-sub-border-radius, 8px);\n        color: var(--ate-primary);\n        flex-shrink: 0;\n        transition: all 0.15s ease;\n      }\n\n      .slash-command-item.selected .slash-command-icon {\n        background: var(--ate-primary);\n        color: var(--ate-primary-contrast, #ffffff);\n      }\n\n      .slash-command-icon .material-symbols-outlined {\n        font-size: 18px;\n      }\n\n      .slash-command-content {\n        flex: 1;\n        min-width: 0;\n      }\n\n      .slash-command-title {\n        font-weight: 500;\n        color: var(--ate-text);\n        font-size: 14px;\n        margin-bottom: 1px;\n        white-space: nowrap;\n        overflow: hidden;\n        text-overflow: ellipsis;\n      }\n\n      .slash-command-description {\n        color: var(--ate-text-secondary);\n        font-size: 11px;\n        white-space: nowrap;\n        overflow: hidden;\n        text-overflow: ellipsis;\n      }\n    `,\n  ],\n})\nexport class AteSlashCommandsComponent implements AfterViewInit, OnDestroy {\n  readonly i18nService = inject(AteI18nService);\n  editor = input.required<Editor>();\n  config = input<AteCustomSlashCommands | undefined>(undefined);\n\n  menuRef = viewChild.required<ElementRef<HTMLDivElement>>(\"menuRef\");\n\n  private tippyInstance: TippyInstance | null = null;\n  private editorCommands = inject(AteEditorCommandsService);\n\n  // Local state\n  private isActive = false;\n  private currentQuery = signal(\"\");\n  private slashRange: { from: number; to: number } | null = null;\n\n  // Signal for selected index\n  selectedIndex = signal(0);\n\n  // Toolbar interaction state (from centralized service)\n  private readonly isToolbarInteracting = this.editorCommands.isToolbarInteracting;\n\n  commands = computed(() => {\n    const config = this.config();\n    if (config && config.commands) {\n      return config.commands;\n    }\n\n    // Fallback to default native commands\n    return createDefaultSlashCommands(this.i18nService, this.editorCommands);\n  });\n\n  filteredCommands = computed(() => {\n    const query = this.currentQuery().toLowerCase();\n    const commands = this.commands();\n\n    if (!query) {\n      return commands;\n    }\n\n    return commands.filter(\n      command =>\n        command.title.toLowerCase().includes(query) ||\n        command.description.toLowerCase().includes(query) ||\n        command.keywords.some(keyword => keyword.toLowerCase().includes(query))\n    );\n  });\n\n  constructor() {\n    effect(() => {\n      const ed = this.editor();\n      if (!ed) {\n        return;\n      }\n\n      // Clean up old listeners\n      ed.off(\"selectionUpdate\", this.updateMenu);\n      ed.off(\"transaction\", this.updateMenu);\n      ed.off(\"focus\", this.updateMenu);\n      ed.off(\"blur\", this.handleBlur);\n\n      // Add new listeners\n      ed.on(\"selectionUpdate\", this.updateMenu);\n      ed.on(\"transaction\", this.updateMenu);\n      ed.on(\"focus\", this.updateMenu);\n      ed.on(\"blur\", this.handleBlur);\n\n      // Use ProseMirror plugin system to intercept keys\n      this.addKeyboardPlugin(ed);\n\n      // updateMenu() will be called automatically when editor is ready\n    }, { allowSignalWrites: true });\n  }\n\n  ngAfterViewInit() {\n    this.initTippy();\n  }\n\n  ngOnDestroy() {\n    const ed = this.editor();\n    if (ed) {\n      ed.off(\"selectionUpdate\", this.updateMenu);\n      ed.off(\"transaction\", this.updateMenu);\n      ed.off(\"focus\", this.updateMenu);\n      ed.off(\"blur\", this.handleBlur);\n    }\n\n    if (this.tippyInstance) {\n      this.tippyInstance.destroy();\n      this.tippyInstance = null;\n    }\n  }\n\n  private initTippy() {\n    const nativeElement = this.menuRef().nativeElement;\n    if (!nativeElement) {return;}\n\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: \"slash-menu\",\n      appendTo: _ref => {\n        // Always try to climb up to editor host to inherit CSS variables\n        const host = (this.editor().options.element as HTMLElement).closest(\n          \"angular-tiptap-editor\"\n        );\n        return host || document.body;\n      },\n      interactive: true,\n      arrow: false,\n      offset: [0, 8],\n      hideOnClick: true,\n      plugins: [sticky],\n      sticky: false,\n      getReferenceClientRect: () => this.getSlashRect(),\n      // Improve positioning with scroll\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: [\"top-start\", \"bottom-end\", \"top-end\"],\n            },\n          },\n          {\n            name: \"hide\",\n          },\n        ],\n      },\n    });\n\n    // Initial check after Tippy is initialized\n    this.updateMenu();\n  }\n\n  private getSlashRect(): DOMRect {\n    const ed = this.editor();\n    if (!ed || !this.slashRange) {\n      return new DOMRect(-9999, -9999, 0, 0);\n    }\n\n    try {\n      // Use ProseMirror coordinates for better precision\n      const coords = ed.view.coordsAtPos(this.slashRange.from);\n      return new DOMRect(coords.left, coords.top, 0, coords.bottom - coords.top);\n    } catch (error) {\n      console.warn(\"Error calculating coordinates:\", error);\n      // Fallback to window.getSelection\n      const selection = window.getSelection();\n      if (!selection || selection.rangeCount === 0) {\n        return new DOMRect(-9999, -9999, 0, 0);\n      }\n      const range = selection.getRangeAt(0);\n      return range.getBoundingClientRect();\n    }\n  }\n\n  updateMenu = () => {\n    const ed = this.editor();\n    if (!ed) {\n      return;\n    }\n\n    const { from } = ed.state.selection;\n\n    // Check if '/' was typed at the beginning of a line or after a space\n    const textBefore = ed.state.doc.textBetween(Math.max(0, from - 20), from, \"\\n\");\n    const slashMatch = textBefore.match(/(?:^|\\s)\\/([^/\\s]*)$/);\n\n    if (slashMatch) {\n      const query = slashMatch[1] || \"\";\n      const wasActive = this.isActive;\n\n      this.currentQuery.set(query);\n      this.slashRange = {\n        from: from - slashMatch[0].length + slashMatch[0].indexOf(\"/\"),\n        to: from,\n      };\n\n      // Reset index if menu just became active\n      if (!wasActive) {\n        this.selectedIndex.set(0);\n      }\n\n      this.isActive = true;\n\n      if (this.isToolbarInteracting()) {\n        this.hideTippy();\n      } else {\n        this.showTippy();\n      }\n    } else {\n      this.isActive = false;\n      this.hideTippy();\n    }\n  };\n\n  handleBlur = () => {\n    setTimeout(() => this.hideTippy(), 100);\n  };\n\n  private scrollToSelected() {\n    // Scroll to the selected element\n    const menuEl = this.menuRef()?.nativeElement;\n    if (menuEl) {\n      const selectedItem = menuEl.querySelector(\".slash-command-item.selected\") as HTMLElement;\n      if (selectedItem) {\n        selectedItem.scrollIntoView({ block: \"nearest\", behavior: \"smooth\" });\n      }\n    }\n  }\n\n  private showTippy() {\n    if (this.tippyInstance && this.filteredCommands().length > 0) {\n      this.tippyInstance.setProps({ sticky: \"reference\" });\n      this.tippyInstance.show();\n    }\n  }\n\n  private hideTippy() {\n    if (this.tippyInstance) {\n      this.tippyInstance.setProps({ sticky: false });\n      this.tippyInstance.hide();\n    }\n  }\n\n  executeCommand(command: AteSlashCommandItem) {\n    const ed = this.editor();\n    if (!ed || !this.slashRange) {\n      return;\n    }\n\n    // Remove slash text (\"/\")\n    const { tr } = ed.state;\n    tr.delete(this.slashRange.from, this.slashRange.to);\n    ed.view.dispatch(tr);\n\n    // Hide menu immediately\n    this.hideTippy();\n    this.isActive = false;\n\n    // Give focus back to editor and execute command\n    // Use a micro-delay to ensure ProseMirror DOM is stable after removing \"/\"\n    setTimeout(() => {\n      ed.commands.focus();\n      command.command(ed);\n    }, 10);\n  }\n\n  private addKeyboardPlugin(ed: Editor) {\n    // Add a ProseMirror plugin to intercept keyboard events\n    const keyboardPlugin = new Plugin({\n      key: new PluginKey(\"slash-commands-keyboard\"),\n      props: {\n        handleKeyDown: (view: EditorView, event: KeyboardEvent) => {\n          // Only handle if menu is active\n          if (!this.isActive || this.filteredCommands().length === 0) {\n            return false;\n          }\n\n          switch (event.key) {\n            case \"ArrowDown\": {\n              event.preventDefault();\n              const nextIndex = (this.selectedIndex() + 1) % this.filteredCommands().length;\n              this.selectedIndex.set(nextIndex);\n              this.scrollToSelected();\n              return true;\n            }\n            case \"ArrowUp\": {\n              event.preventDefault();\n              const prevIndex =\n                this.selectedIndex() === 0\n                  ? this.filteredCommands().length - 1\n                  : this.selectedIndex() - 1;\n              this.selectedIndex.set(prevIndex);\n              this.scrollToSelected();\n              return true;\n            }\n            case \"Enter\": {\n              event.preventDefault();\n              const selectedCommand = this.filteredCommands()[this.selectedIndex()];\n              if (selectedCommand) {\n                this.executeCommand(selectedCommand);\n              }\n              return true;\n            }\n            case \"Escape\": {\n              event.preventDefault();\n              this.isActive = false;\n              this.hideTippy();\n              // Remove typed \"/\"\n              if (this.slashRange) {\n                const { tr } = view.state;\n                tr.delete(this.slashRange.from, this.slashRange.to);\n                view.dispatch(tr);\n              }\n              return true;\n            }\n          }\n\n          return false;\n        },\n      },\n    });\n\n    // Add plugin to editor\n    ed.view.updateState(\n      ed.view.state.reconfigure({\n        plugins: [keyboardPlugin, ...ed.view.state.plugins],\n      })\n    );\n  }\n}\n"]}