@flogeez/angular-tiptap-editor 3.1.3 → 3.1.4

package/esm2022/lib/components/editor/ate-block-controls.component.mjs

@@ -0,0 +1,256 @@
+import { Component, input, viewChild, effect, signal, inject, ChangeDetectionStrategy, } from "@angular/core";
+import tippy, { sticky } from "tippy.js";
+import { AteI18nService } from "../../services/ate-i18n.service";
+import { AteTooltipDirective } from "../../directives/ate-tooltip.directive";
+import * as i0 from "@angular/core";
+/**
+ * Component providing Notion-like block controls (Plus button and Drag Handle).
+ */
+export class AteBlockControlsComponent {
+    constructor() {
+        this.i18n = inject(AteI18nService);
+        this.editor = input.required();
+        this.hoveredData = input(null);
+        this.menuRef = viewChild.required("menuRef");
+        this.isInteracting = signal(false);
+        this.lastValidData = null;
+        this.lastValidRect = null;
+        this.tippyInstance = null;
+        this.updateTimeout = null;
+        effect(() => {
+            const data = this.hoveredData();
+            const interacting = this.isInteracting();
+            if (data) {
+                this.lastValidData = data;
+                this.lastValidRect = data.element.getBoundingClientRect();
+            }
+            this.updateMenu(!!data || interacting);
+        });
+    }
+    ngAfterViewInit() {
+        this.initTippy();
+    }
+    ngOnDestroy() {
+        if (this.updateTimeout) {
+            window.clearTimeout(this.updateTimeout);
+        }
+        if (this.tippyInstance) {
+            this.tippyInstance.destroy();
+            this.tippyInstance = null;
+        }
+    }
+    initTippy() {
+        const nativeElement = this.menuRef().nativeElement;
+        if (!nativeElement) {
+            return;
+        }
+        this.tippyInstance = tippy(document.body, {
+            content: nativeElement,
+            trigger: "manual",
+            placement: "left",
+            theme: "ate-block-controls",
+            appendTo: () => this.editor()?.options?.element || document.body,
+            interactive: true,
+            hideOnClick: false,
+            arrow: false,
+            offset: [0, 8],
+            zIndex: 99,
+            plugins: [sticky],
+            sticky: "reference",
+            moveTransition: "transform 0.2s ease-out",
+            getReferenceClientRect: () => this.getSelectionRect(),
+            popperOptions: {
+                modifiers: [
+                    {
+                        name: "preventOverflow",
+                        options: {
+                            boundary: this.editor()?.options?.element || document.body,
+                            padding: 8,
+                        },
+                    },
+                ],
+            },
+        });
+    }
+    updateMenu(show) {
+        if (this.updateTimeout) {
+            window.clearTimeout(this.updateTimeout);
+        }
+        const delay = show ? 0 : 400;
+        this.updateTimeout = window.setTimeout(() => {
+            if (show) {
+                this.showTippy();
+            }
+            else {
+                this.hideTippy();
+            }
+        }, delay);
+    }
+    showTippy() {
+        if (this.tippyInstance) {
+            this.tippyInstance.setProps({
+                getReferenceClientRect: () => this.getSelectionRect(),
+            });
+            this.tippyInstance.show();
+        }
+    }
+    hideTippy() {
+        if (this.tippyInstance) {
+            this.tippyInstance.hide();
+        }
+    }
+    getSelectionRect() {
+        const data = this.hoveredData();
+        if (data && data.element) {
+            return data.element.getBoundingClientRect();
+        }
+        return this.lastValidRect || new DOMRect(-9999, -9999, 0, 0);
+    }
+    onMouseEnter() {
+        this.isInteracting.set(true);
+    }
+    onMouseLeave() {
+        this.isInteracting.set(false);
+    }
+    onContainerMouseDown(event) {
+        if (event.target === event.currentTarget) {
+            event.preventDefault();
+        }
+    }
+    onButtonMouseDown(event) {
+        event.preventDefault();
+    }
+    /**
+     * Selection strategy to avoid partial node dragging (ghost table issue).
+     */
+    onDragHandleMouseDown(event) {
+        event.stopPropagation();
+        const ed = this.editor();
+        const data = this.hoveredData() || this.lastValidData;
+        if (ed && data) {
+            // Force whole-node selection. This is crucial for atomic nodes like tables and images.
+            ed.commands.setNodeSelection(data.pos);
+        }
+    }
+    addBlock(event) {
+        event.stopPropagation();
+        const ed = this.editor();
+        const data = this.hoveredData() || this.lastValidData;
+        if (!ed || !data) {
+            return;
+        }
+        const { pos, node } = data;
+        if (node.content.size === 0) {
+            ed.chain()
+                .focus()
+                .setTextSelection(pos + 1)
+                .insertContent("/")
+                .run();
+        }
+        else {
+            const nextPos = pos + node.nodeSize;
+            ed.chain()
+                .focus()
+                .insertContentAt(nextPos, { type: "paragraph", content: [{ type: "text", text: "/" }] })
+                .setTextSelection(nextPos + 2)
+                .run();
+        }
+        this.isInteracting.set(false);
+        this.hideTippy();
+    }
+    onDragStart(event) {
+        const ed = this.editor();
+        const data = this.hoveredData() || this.lastValidData;
+        if (!ed || !data || !event.dataTransfer) {
+            return;
+        }
+        const { element, pos } = data;
+        const view = ed.view;
+        // 1. Force the editor to focus and select the ENTIRE node
+        view.focus();
+        ed.commands.setNodeSelection(pos);
+        // 2. Browser Drag Image & metadata
+        event.dataTransfer.setDragImage(element, 0, 10);
+        event.dataTransfer.effectAllowed = "move";
+        event.dataTransfer.setData("text/plain", "");
+        // 3. PRO-HACK: Indicate this is a move of the current selection (the whole node)
+        view.dragging = {
+            slice: ed.state.selection.content(),
+            move: true,
+        };
+        // 4. Dispatch virtual dragstart
+        const pmEvent = new DragEvent("dragstart", {
+            dataTransfer: event.dataTransfer,
+            bubbles: true,
+            cancelable: true,
+        });
+        element.dispatchEvent(pmEvent);
+        // 5. Cleanup UI
+        setTimeout(() => {
+            this.hideTippy();
+            this.isInteracting.set(false);
+        }, 0);
+    }
+    onDragEnd() {
+        this.isInteracting.set(false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteBlockControlsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.14", type: AteBlockControlsComponent, isStandalone: true, selector: "ate-block-controls", inputs: { editor: { classPropertyName: "editor", publicName: "editor", isSignal: true, isRequired: true, transformFunction: null }, hoveredData: { classPropertyName: "hoveredData", publicName: "hoveredData", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "menuRef", first: true, predicate: ["menuRef"], descendants: true, isSignal: true }], ngImport: i0, template: `
+    <div
+      #menuRef
+      class="ate-block-controls"
+      (mouseenter)="onMouseEnter()"
+      (mouseleave)="onMouseLeave()"
+      (mousedown)="onContainerMouseDown($event)">
+      <button
+        class="ate-control-btn ate-block-add"
+        (mousedown)="onButtonMouseDown($event)"
+        (click)="addBlock($event)"
+        [ateTooltip]="i18n.editor().blockAdd"
+        ateTooltipPlacement="top">
+        <span class="material-symbols-outlined">add</span>
+      </button>
+      <div
+        class="ate-control-btn ate-block-drag"
+        draggable="true"
+        (mousedown)="onDragHandleMouseDown($event)"
+        (dragstart)="onDragStart($event)"
+        (dragend)="onDragEnd()"
+        [ateTooltip]="i18n.editor().blockDrag"
+        ateTooltipPlacement="top">
+        <span class="material-symbols-outlined">drag_indicator</span>
+      </div>
+    </div>
+  `, isInline: true, styles: [".ate-block-controls{display:flex;align-items:center;gap:2px;padding:4px;pointer-events:auto;will-change:transform}.ate-control-btn{display:flex;align-items:center;justify-content:center;width:24px;height:24px;border-radius:4px;border:none;background:transparent;color:var(--ate-text-secondary);cursor:pointer;transition:all .15s ease}.ate-control-btn:hover{background:var(--ate-surface-tertiary);color:var(--ate-text)}.ate-control-btn .material-symbols-outlined{font-size:18px}@media (max-width: 768px){:host{display:none!important}}\n"], dependencies: [{ kind: "directive", type: AteTooltipDirective, selector: "[ateTooltip]", inputs: ["ateTooltip", "ateTooltipPlacement", "ateTooltipDelay", "ateTooltipDisabled"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteBlockControlsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "ate-block-controls", standalone: true, imports: [AteTooltipDirective], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div
+      #menuRef
+      class="ate-block-controls"
+      (mouseenter)="onMouseEnter()"
+      (mouseleave)="onMouseLeave()"
+      (mousedown)="onContainerMouseDown($event)">
+      <button
+        class="ate-control-btn ate-block-add"
+        (mousedown)="onButtonMouseDown($event)"
+        (click)="addBlock($event)"
+        [ateTooltip]="i18n.editor().blockAdd"
+        ateTooltipPlacement="top">
+        <span class="material-symbols-outlined">add</span>
+      </button>
+      <div
+        class="ate-control-btn ate-block-drag"
+        draggable="true"
+        (mousedown)="onDragHandleMouseDown($event)"
+        (dragstart)="onDragStart($event)"
+        (dragend)="onDragEnd()"
+        [ateTooltip]="i18n.editor().blockDrag"
+        ateTooltipPlacement="top">
+        <span class="material-symbols-outlined">drag_indicator</span>
+      </div>
+    </div>
+  `, styles: [".ate-block-controls{display:flex;align-items:center;gap:2px;padding:4px;pointer-events:auto;will-change:transform}.ate-control-btn{display:flex;align-items:center;justify-content:center;width:24px;height:24px;border-radius:4px;border:none;background:transparent;color:var(--ate-text-secondary);cursor:pointer;transition:all .15s ease}.ate-control-btn:hover{background:var(--ate-surface-tertiary);color:var(--ate-text)}.ate-control-btn .material-symbols-outlined{font-size:18px}@media (max-width: 768px){:host{display:none!important}}\n"] }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ate-block-controls.component.js","sourceRoot":"","sources":["../../../../../../projects/angular-tiptap-editor/src/lib/components/editor/ate-block-controls.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  input,\n  viewChild,\n  ElementRef,\n  OnDestroy,\n  effect,\n  signal,\n  inject,\n  ChangeDetectionStrategy,\n  AfterViewInit,\n} from \"@angular/core\";\nimport tippy, { Instance as TippyInstance, sticky } from \"tippy.js\";\nimport { Editor } from \"@tiptap/core\";\nimport { Node as PMNode } from \"@tiptap/pm/model\";\nimport { AteI18nService } from \"../../services/ate-i18n.service\";\nimport { AteTooltipDirective } from \"../../directives/ate-tooltip.directive\";\n\n/**\n * Component providing Notion-like block controls (Plus button and Drag Handle).\n */\n@Component({\n  selector: \"ate-block-controls\",\n  standalone: true,\n  imports: [AteTooltipDirective],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div\n      #menuRef\n      class=\"ate-block-controls\"\n      (mouseenter)=\"onMouseEnter()\"\n      (mouseleave)=\"onMouseLeave()\"\n      (mousedown)=\"onContainerMouseDown($event)\">\n      <button\n        class=\"ate-control-btn ate-block-add\"\n        (mousedown)=\"onButtonMouseDown($event)\"\n        (click)=\"addBlock($event)\"\n        [ateTooltip]=\"i18n.editor().blockAdd\"\n        ateTooltipPlacement=\"top\">\n        <span class=\"material-symbols-outlined\">add</span>\n      </button>\n      <div\n        class=\"ate-control-btn ate-block-drag\"\n        draggable=\"true\"\n        (mousedown)=\"onDragHandleMouseDown($event)\"\n        (dragstart)=\"onDragStart($event)\"\n        (dragend)=\"onDragEnd()\"\n        [ateTooltip]=\"i18n.editor().blockDrag\"\n        ateTooltipPlacement=\"top\">\n        <span class=\"material-symbols-outlined\">drag_indicator</span>\n      </div>\n    </div>\n  `,\n  styles: [\n    `\n      .ate-block-controls {\n        display: flex;\n        align-items: center;\n        gap: 2px;\n        padding: 4px;\n        pointer-events: auto;\n        will-change: transform;\n      }\n\n      .ate-control-btn {\n        display: flex;\n        align-items: center;\n        justify-content: center;\n        width: 24px;\n        height: 24px;\n        border-radius: 4px;\n        border: none;\n        background: transparent;\n        color: var(--ate-text-secondary);\n        cursor: pointer;\n        transition: all 0.15s ease;\n      }\n\n      .ate-control-btn:hover {\n        background: var(--ate-surface-tertiary);\n        color: var(--ate-text);\n      }\n\n      .ate-control-btn .material-symbols-outlined {\n        font-size: 18px;\n      }\n\n      @media (max-width: 768px) {\n        :host {\n          display: none !important;\n        }\n      }\n    `,\n  ],\n})\nexport class AteBlockControlsComponent implements AfterViewInit, OnDestroy {\n  protected readonly i18n = inject(AteI18nService);\n\n  editor = input.required<Editor>();\n  hoveredData = input<{ node: PMNode; element: HTMLElement; pos: number } | null>(null);\n\n  menuRef = viewChild.required<ElementRef<HTMLDivElement>>(\"menuRef\");\n\n  protected isInteracting = signal(false);\n  private lastValidData: { node: PMNode; element: HTMLElement; pos: number } | null = null;\n  private lastValidRect: DOMRect | null = null;\n  private tippyInstance: TippyInstance | null = null;\n  private updateTimeout: number | null = null;\n\n  constructor() {\n    effect(() => {\n      const data = this.hoveredData();\n      const interacting = this.isInteracting();\n\n      if (data) {\n        this.lastValidData = data;\n        this.lastValidRect = data.element.getBoundingClientRect();\n      }\n\n      this.updateMenu(!!data || interacting);\n    });\n  }\n\n  ngAfterViewInit() {\n    this.initTippy();\n  }\n\n  ngOnDestroy() {\n    if (this.updateTimeout) {\n      window.clearTimeout(this.updateTimeout);\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) {\n      return;\n    }\n\n    this.tippyInstance = tippy(document.body, {\n      content: nativeElement,\n      trigger: \"manual\",\n      placement: \"left\",\n      theme: \"ate-block-controls\",\n      appendTo: () => (this.editor()?.options?.element as HTMLElement) || document.body,\n      interactive: true,\n      hideOnClick: false,\n      arrow: false,\n      offset: [0, 8],\n      zIndex: 99,\n      plugins: [sticky],\n      sticky: \"reference\",\n      moveTransition: \"transform 0.2s ease-out\",\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      },\n    });\n  }\n\n  private updateMenu(show: boolean) {\n    if (this.updateTimeout) {\n      window.clearTimeout(this.updateTimeout);\n    }\n    const delay = show ? 0 : 400;\n    this.updateTimeout = window.setTimeout(() => {\n      if (show) {\n        this.showTippy();\n      } else {\n        this.hideTippy();\n      }\n    }, delay);\n  }\n\n  private showTippy() {\n    if (this.tippyInstance) {\n      this.tippyInstance.setProps({\n        getReferenceClientRect: () => this.getSelectionRect(),\n      });\n      this.tippyInstance.show();\n    }\n  }\n\n  private hideTippy() {\n    if (this.tippyInstance) {\n      this.tippyInstance.hide();\n    }\n  }\n\n  private getSelectionRect(): DOMRect {\n    const data = this.hoveredData();\n    if (data && data.element) {\n      return data.element.getBoundingClientRect();\n    }\n    return this.lastValidRect || new DOMRect(-9999, -9999, 0, 0);\n  }\n\n  onMouseEnter() {\n    this.isInteracting.set(true);\n  }\n\n  onMouseLeave() {\n    this.isInteracting.set(false);\n  }\n\n  onContainerMouseDown(event: MouseEvent) {\n    if (event.target === event.currentTarget) {\n      event.preventDefault();\n    }\n  }\n\n  onButtonMouseDown(event: MouseEvent) {\n    event.preventDefault();\n  }\n\n  /**\n   * Selection strategy to avoid partial node dragging (ghost table issue).\n   */\n  onDragHandleMouseDown(event: MouseEvent) {\n    event.stopPropagation();\n    const ed = this.editor();\n    const data = this.hoveredData() || this.lastValidData;\n    if (ed && data) {\n      // Force whole-node selection. This is crucial for atomic nodes like tables and images.\n      ed.commands.setNodeSelection(data.pos);\n    }\n  }\n\n  addBlock(event: MouseEvent) {\n    event.stopPropagation();\n    const ed = this.editor();\n    const data = this.hoveredData() || this.lastValidData;\n    if (!ed || !data) {\n      return;\n    }\n\n    const { pos, node } = data;\n    if (node.content.size === 0) {\n      ed.chain()\n        .focus()\n        .setTextSelection(pos + 1)\n        .insertContent(\"/\")\n        .run();\n    } else {\n      const nextPos = pos + node.nodeSize;\n      ed.chain()\n        .focus()\n        .insertContentAt(nextPos, { type: \"paragraph\", content: [{ type: \"text\", text: \"/\" }] })\n        .setTextSelection(nextPos + 2)\n        .run();\n    }\n\n    this.isInteracting.set(false);\n    this.hideTippy();\n  }\n\n  onDragStart(event: DragEvent) {\n    const ed = this.editor();\n    const data = this.hoveredData() || this.lastValidData;\n    if (!ed || !data || !event.dataTransfer) {\n      return;\n    }\n\n    const { element, pos } = data;\n    const view = ed.view;\n\n    // 1. Force the editor to focus and select the ENTIRE node\n    view.focus();\n    ed.commands.setNodeSelection(pos);\n\n    // 2. Browser Drag Image & metadata\n    event.dataTransfer.setDragImage(element, 0, 10);\n    event.dataTransfer.effectAllowed = \"move\";\n    event.dataTransfer.setData(\"text/plain\", \"\");\n\n    // 3. PRO-HACK: Indicate this is a move of the current selection (the whole node)\n    (view as unknown as { dragging: unknown }).dragging = {\n      slice: ed.state.selection.content(),\n      move: true,\n    };\n\n    // 4. Dispatch virtual dragstart\n    const pmEvent = new DragEvent(\"dragstart\", {\n      dataTransfer: event.dataTransfer,\n      bubbles: true,\n      cancelable: true,\n    });\n    element.dispatchEvent(pmEvent);\n\n    // 5. Cleanup UI\n    setTimeout(() => {\n      this.hideTippy();\n      this.isInteracting.set(false);\n    }, 0);\n  }\n\n  onDragEnd() {\n    this.isInteracting.set(false);\n  }\n}\n"]}