@flogeez/angular-tiptap-editor 3.1.2 → 3.1.4

package/esm2022/lib/directives/ate-tooltip.directive.mjs

@@ -0,0 +1,138 @@
+import { Directive, ElementRef, input, inject, effect, computed } from "@angular/core";
+import tippy from "tippy.js";
+import * as i0 from "@angular/core";
+// Pre-calculate platform once to avoid repeated checks
+const IS_MAC = typeof window !== "undefined" && /Mac|iPod|iPhone|iPad/.test(navigator.platform);
+export class AteTooltipDirective {
+    constructor() {
+        this.el = inject(ElementRef);
+        this.tippyInstance = null;
+        // Signal Inputs
+        this.content = input(null, { alias: "ateTooltip" });
+        this.placement = input("top", { alias: "ateTooltipPlacement" });
+        this.delay = input([200, 50], { alias: "ateTooltipDelay" });
+        this.disabled = input(false, { alias: "ateTooltipDisabled" });
+        /**
+         * Computed logic for ARIA shortcuts.
+         */
+        this.ariaShortcut = computed(() => {
+            const text = this.content();
+            if (!text || !text.includes("\n")) {
+                return null;
+            }
+            return text.split("\n")[1].replace(/\+/g, " ");
+        });
+        /**
+         * Computed logic for Tippy content.
+         * Includes strict escaping of dynamic content to prevent XSS.
+         */
+        this.processedTooltip = computed(() => {
+            const text = this.content();
+            if (!text) {
+                return { content: "", isHTML: false };
+            }
+            if (text.includes("\n")) {
+                const [label, shortcut] = text.split("\n");
+                // Escape dynamic parts to prevent XSS before wrapping in safe HTML
+                const safeLabel = this.escapeHtml(label);
+                let safeShortcut = this.escapeHtml(shortcut);
+                if (IS_MAC) {
+                    safeShortcut = safeShortcut.replace(/Ctrl\+/g, "⌘").replace(/Mod\+/g, "⌘");
+                }
+                else {
+                    safeShortcut = safeShortcut.replace(/Mod\+/g, "Ctrl+");
+                }
+                return {
+                    content: `<div class="ate-tooltip-label">${safeLabel}</div><div class="ate-tooltip-shortcut"><kbd>${safeShortcut}</kbd></div>`,
+                    isHTML: true,
+                };
+            }
+            // No newline? Keep it as plain text (Tippy handles string as text by default)
+            return { content: text, isHTML: false };
+        });
+        effect(() => {
+            const { content, isHTML } = this.processedTooltip();
+            const placement = this.placement();
+            const delay = this.delay();
+            const isDisabled = this.disabled();
+            if (isDisabled || !content) {
+                this.destroyTippy();
+                return;
+            }
+            if (!this.tippyInstance) {
+                this.initTippy(content, isHTML, placement, delay);
+            }
+            else {
+                this.tippyInstance.setProps({
+                    content,
+                    allowHTML: isHTML,
+                    placement,
+                    delay,
+                });
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.destroyTippy();
+    }
+    /**
+     * Basic HTML escaping for security.
+     * Effectively neutralizes scripts or malicious HTML tags.
+     */
+    escapeHtml(unsafe) {
+        return unsafe
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;")
+            .replace(/"/g, "&quot;")
+            .replace(/'/g, "&#039;");
+    }
+    initTippy(content, allowHTML, placement, delay) {
+        const container = this.el.nativeElement.closest(".ate-editor") || document.body;
+        this.tippyInstance = tippy(this.el.nativeElement, {
+            content,
+            allowHTML,
+            placement,
+            delay,
+            duration: [100, 100],
+            offset: [0, 6],
+            theme: "ate-tooltip",
+            touch: ["hold", 500],
+            maxWidth: 250,
+            appendTo: () => container,
+            aria: {
+                content: "describedby",
+            },
+            popperOptions: {
+                modifiers: [
+                    {
+                        name: "preventOverflow",
+                        options: {
+                            boundary: document.body,
+                            padding: 8,
+                        },
+                    },
+                ],
+            },
+        });
+    }
+    destroyTippy() {
+        if (this.tippyInstance) {
+            this.tippyInstance.destroy();
+            this.tippyInstance = null;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteTooltipDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.14", type: AteTooltipDirective, isStandalone: true, selector: "[ateTooltip]", inputs: { content: { classPropertyName: "content", publicName: "ateTooltip", isSignal: true, isRequired: false, transformFunction: null }, placement: { classPropertyName: "placement", publicName: "ateTooltipPlacement", isSignal: true, isRequired: false, transformFunction: null }, delay: { classPropertyName: "delay", publicName: "ateTooltipDelay", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "ateTooltipDisabled", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "attr.aria-keyshortcuts": "ariaShortcut()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteTooltipDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[ateTooltip]",
+                    standalone: true,
+                    host: {
+                        "[attr.aria-keyshortcuts]": "ariaShortcut()",
+                    },
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ate-tooltip.directive.js","sourceRoot":"","sources":["../../../../../projects/angular-tiptap-editor/src/lib/directives/ate-tooltip.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, input, OnDestroy, inject, effect, computed } from \"@angular/core\";\nimport tippy, { Instance as TippyInstance, Placement } from \"tippy.js\";\n\n// Pre-calculate platform once to avoid repeated checks\nconst IS_MAC = typeof window !== \"undefined\" && /Mac|iPod|iPhone|iPad/.test(navigator.platform);\n\n@Directive({\n  selector: \"[ateTooltip]\",\n  standalone: true,\n  host: {\n    \"[attr.aria-keyshortcuts]\": \"ariaShortcut()\",\n  },\n})\nexport class AteTooltipDirective implements OnDestroy {\n  private readonly el = inject(ElementRef);\n  private tippyInstance: TippyInstance | null = null;\n\n  // Signal Inputs\n  content = input<string | null>(null, { alias: \"ateTooltip\" });\n  placement = input<Placement>(\"top\", { alias: \"ateTooltipPlacement\" });\n  delay = input<number | [number, number]>([200, 50], { alias: \"ateTooltipDelay\" });\n  disabled = input<boolean>(false, { alias: \"ateTooltipDisabled\" });\n\n  /**\n   * Computed logic for ARIA shortcuts.\n   */\n  protected readonly ariaShortcut = computed(() => {\n    const text = this.content();\n    if (!text || !text.includes(\"\\n\")) {\n      return null;\n    }\n    return text.split(\"\\n\")[1].replace(/\\+/g, \" \");\n  });\n\n  /**\n   * Computed logic for Tippy content.\n   * Includes strict escaping of dynamic content to prevent XSS.\n   */\n  private readonly processedTooltip = computed(() => {\n    const text = this.content();\n    if (!text) {\n      return { content: \"\", isHTML: false };\n    }\n\n    if (text.includes(\"\\n\")) {\n      const [label, shortcut] = text.split(\"\\n\");\n\n      // Escape dynamic parts to prevent XSS before wrapping in safe HTML\n      const safeLabel = this.escapeHtml(label);\n      let safeShortcut = this.escapeHtml(shortcut);\n\n      if (IS_MAC) {\n        safeShortcut = safeShortcut.replace(/Ctrl\\+/g, \"⌘\").replace(/Mod\\+/g, \"⌘\");\n      } else {\n        safeShortcut = safeShortcut.replace(/Mod\\+/g, \"Ctrl+\");\n      }\n\n      return {\n        content: `<div class=\"ate-tooltip-label\">${safeLabel}</div><div class=\"ate-tooltip-shortcut\"><kbd>${safeShortcut}</kbd></div>`,\n        isHTML: true,\n      };\n    }\n\n    // No newline? Keep it as plain text (Tippy handles string as text by default)\n    return { content: text, isHTML: false };\n  });\n\n  constructor() {\n    effect(() => {\n      const { content, isHTML } = this.processedTooltip();\n      const placement = this.placement();\n      const delay = this.delay();\n      const isDisabled = this.disabled();\n\n      if (isDisabled || !content) {\n        this.destroyTippy();\n        return;\n      }\n\n      if (!this.tippyInstance) {\n        this.initTippy(content, isHTML, placement, delay);\n      } else {\n        this.tippyInstance.setProps({\n          content,\n          allowHTML: isHTML,\n          placement,\n          delay,\n        });\n      }\n    });\n  }\n\n  ngOnDestroy(): void {\n    this.destroyTippy();\n  }\n\n  /**\n   * Basic HTML escaping for security.\n   * Effectively neutralizes scripts or malicious HTML tags.\n   */\n  private escapeHtml(unsafe: string): string {\n    return unsafe\n      .replace(/&/g, \"&amp;\")\n      .replace(/</g, \"&lt;\")\n      .replace(/>/g, \"&gt;\")\n      .replace(/\"/g, \"&quot;\")\n      .replace(/'/g, \"&#039;\");\n  }\n\n  private initTippy(\n    content: string,\n    allowHTML: boolean,\n    placement: Placement,\n    delay: number | [number, number]\n  ): void {\n    const container = this.el.nativeElement.closest(\".ate-editor\") || document.body;\n\n    this.tippyInstance = tippy(this.el.nativeElement, {\n      content,\n      allowHTML,\n      placement,\n      delay,\n      duration: [100, 100],\n      offset: [0, 6],\n      theme: \"ate-tooltip\",\n      touch: [\"hold\", 500],\n      maxWidth: 250,\n      appendTo: () => container,\n      aria: {\n        content: \"describedby\",\n      },\n      popperOptions: {\n        modifiers: [\n          {\n            name: \"preventOverflow\",\n            options: {\n              boundary: document.body,\n              padding: 8,\n            },\n          },\n        ],\n      },\n    }) as unknown as TippyInstance;\n  }\n\n  private destroyTippy(): void {\n    if (this.tippyInstance) {\n      this.tippyInstance.destroy();\n      this.tippyInstance = null;\n    }\n  }\n}\n"]}

package/esm2022/lib/extensions/ate-block-controls.extension.mjs

@@ -0,0 +1,156 @@
+import { Extension } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+// Helper to get the DOM element properly
+function getDomElement(view, pos) {
+    const dom = view.nodeDOM(pos);
+    if (!dom) {
+        return null;
+    }
+    if (dom instanceof HTMLElement) {
+        return dom;
+    }
+    return dom.parentElement;
+}
+// VERTICAL SCAN (For the empty margin)
+function findBlockElementAtY(view, y) {
+    const editorDom = view.dom;
+    const children = Array.from(editorDom.children);
+    // We look for the direct child of the editor (Level 1) that intercepts the Y line
+    return (children.find(child => {
+        if (getComputedStyle(child).position === "absolute") {
+            return false;
+        }
+        const rect = child.getBoundingClientRect();
+        // Tolérance de 5px
+        return y >= rect.top - 5 && y <= rect.bottom + 5;
+    }) || null);
+}
+function resolveBlockData(view, y, targetElement) {
+    let blockEl = null;
+    // 1. FAST PATH : Direct target
+    // LEVEL 1: We look for the first parent element that is a direct child of the editor
+    if (targetElement && !targetElement.classList.contains("ProseMirror")) {
+        blockEl = targetElement.closest(".ProseMirror > *");
+    }
+    // 2. GUTTER PATH : Vertical scan
+    if (!blockEl) {
+        blockEl = findBlockElementAtY(view, y);
+    }
+    if (!blockEl) {
+        return null;
+    }
+    // 3. PROSEMIRROR NODE RESOLUTION
+    try {
+        // We ask for the position at the beginning of this root block
+        const pos = view.posAtDOM(blockEl, 0);
+        const $pos = view.state.doc.resolve(pos);
+        // CASE A : STANDARD BLOCKS (H1, P, Lists, Blockquotes...)
+        // We make sure to take the node of depth 1 (Direct child of the Doc)
+        if ($pos.depth >= 1) {
+            const rootNode = $pos.node(1);
+            const rootPos = $pos.before(1);
+            const rootElement = getDomElement(view, rootPos);
+            // Sécurité : on vérifie que l'élément DOM correspond bien
+            if (rootNode && (rootElement || blockEl)) {
+                return { node: rootNode, element: rootElement || blockEl, pos: rootPos };
+            }
+        }
+        // CASE B : IMAGES / ATOMS (Depth 0)
+        // Sometimes a root image is seen as Depth 0 by resolve()
+        // We look at the node right after the position
+        if ($pos.depth === 0) {
+            const nodeAfter = $pos.nodeAfter;
+            if (nodeAfter && (nodeAfter.isBlock || nodeAfter.isAtom)) {
+                return { node: nodeAfter, element: blockEl, pos: pos };
+            }
+        }
+    }
+    catch (_e) {
+        // console.warn(_e);
+    }
+    return null;
+}
+export const AteBlockControlsExtension = Extension.create({
+    name: "ateBlockControls",
+    addOptions() {
+        return { onHover: undefined };
+    },
+    addProseMirrorPlugins() {
+        let lastHoveredElement = null;
+        let lastHoveredPos = null;
+        let rafId = null;
+        let lastMouseX = 0;
+        let lastMouseY = 0;
+        const update = (view) => {
+            if (!this.editor.isEditable) {
+                return;
+            }
+            const editorRect = view.dom.getBoundingClientRect();
+            const gutterWidth = 80;
+            // Check Limites (Marge Gauche + Editeur)
+            if (lastMouseY < editorRect.top ||
+                lastMouseY > editorRect.bottom ||
+                lastMouseX > editorRect.right ||
+                lastMouseX < editorRect.left - gutterWidth) {
+                if (lastHoveredElement) {
+                    reset();
+                }
+                return;
+            }
+            // STICKY ANTI-FLICKER
+            // On garde le bloc tant qu'on est dans sa hauteur
+            if (lastHoveredElement && lastHoveredElement.isConnected) {
+                const rect = lastHoveredElement.getBoundingClientRect();
+                if (lastMouseY >= rect.top && lastMouseY <= rect.bottom) {
+                    return;
+                }
+            }
+            const target = document.elementFromPoint(lastMouseX, lastMouseY);
+            const data = resolveBlockData(view, lastMouseY, target);
+            if (data && (data.element !== lastHoveredElement || data.pos !== lastHoveredPos)) {
+                lastHoveredElement = data.element;
+                lastHoveredPos = data.pos;
+                this.options.onHover?.(data);
+            }
+            else if (!data) {
+                if (!lastHoveredElement || !lastHoveredElement.isConnected) {
+                    reset();
+                }
+            }
+        };
+        const reset = () => {
+            this.options.onHover?.(null);
+            lastHoveredElement = null;
+            lastHoveredPos = null;
+        };
+        return [
+            new Plugin({
+                key: new PluginKey("ateBlockControls"),
+                props: {
+                    handleDOMEvents: {
+                        mousemove: (view, event) => {
+                            lastMouseX = event.clientX;
+                            lastMouseY = event.clientY;
+                            if (rafId === null) {
+                                rafId = window.requestAnimationFrame(() => {
+                                    update(view);
+                                    rafId = null;
+                                });
+                            }
+                            return false;
+                        },
+                        mouseleave: () => {
+                            if (rafId) {
+                                window.cancelAnimationFrame(rafId);
+                                rafId = null;
+                            }
+                            reset();
+                            return false;
+                        },
+                    },
+                },
+            }),
+        ];
+    },
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ate-block-controls.extension.js","sourceRoot":"","sources":["../../../../../projects/angular-tiptap-editor/src/lib/extensions/ate-block-controls.extension.ts"],"names":[],"mappings":"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","sourcesContent":["import { Extension } from \"@tiptap/core\";\nimport { Plugin, PluginKey } from \"@tiptap/pm/state\";\nimport { EditorView } from \"@tiptap/pm/view\";\nimport { Node } from \"@tiptap/pm/model\";\n\nexport interface AteBlockControlsOptions {\n  onHover?: (data: { node: Node; element: HTMLElement; pos: number } | null) => void;\n}\n\n// Helper to get the DOM element properly\nfunction getDomElement(view: EditorView, pos: number): HTMLElement | null {\n  const dom = view.nodeDOM(pos);\n  if (!dom) {\n    return null;\n  }\n  if (dom instanceof HTMLElement) {\n    return dom;\n  }\n  return dom.parentElement;\n}\n\n// VERTICAL SCAN (For the empty margin)\nfunction findBlockElementAtY(view: EditorView, y: number): HTMLElement | null {\n  const editorDom = view.dom as HTMLElement;\n  const children = Array.from(editorDom.children) as HTMLElement[];\n\n  // We look for the direct child of the editor (Level 1) that intercepts the Y line\n  return (\n    children.find(child => {\n      if (getComputedStyle(child).position === \"absolute\") {\n        return false;\n      }\n      const rect = child.getBoundingClientRect();\n      // Tolérance de 5px\n      return y >= rect.top - 5 && y <= rect.bottom + 5;\n    }) || null\n  );\n}\n\nfunction resolveBlockData(\n  view: EditorView,\n  y: number,\n  targetElement: HTMLElement | null\n): { node: Node; element: HTMLElement; pos: number } | null {\n  let blockEl: HTMLElement | null = null;\n\n  // 1. FAST PATH : Direct target\n  // LEVEL 1: We look for the first parent element that is a direct child of the editor\n  if (targetElement && !targetElement.classList.contains(\"ProseMirror\")) {\n    blockEl = targetElement.closest(\".ProseMirror > *\") as HTMLElement;\n  }\n\n  // 2. GUTTER PATH : Vertical scan\n  if (!blockEl) {\n    blockEl = findBlockElementAtY(view, y);\n  }\n\n  if (!blockEl) {\n    return null;\n  }\n\n  // 3. PROSEMIRROR NODE RESOLUTION\n  try {\n    // We ask for the position at the beginning of this root block\n    const pos = view.posAtDOM(blockEl, 0);\n    const $pos = view.state.doc.resolve(pos);\n\n    // CASE A : STANDARD BLOCKS (H1, P, Lists, Blockquotes...)\n    // We make sure to take the node of depth 1 (Direct child of the Doc)\n    if ($pos.depth >= 1) {\n      const rootNode = $pos.node(1);\n      const rootPos = $pos.before(1);\n      const rootElement = getDomElement(view, rootPos);\n\n      // Sécurité : on vérifie que l'élément DOM correspond bien\n      if (rootNode && (rootElement || blockEl)) {\n        return { node: rootNode, element: rootElement || blockEl, pos: rootPos };\n      }\n    }\n\n    // CASE B : IMAGES / ATOMS (Depth 0)\n    // Sometimes a root image is seen as Depth 0 by resolve()\n    // We look at the node right after the position\n    if ($pos.depth === 0) {\n      const nodeAfter = $pos.nodeAfter;\n      if (nodeAfter && (nodeAfter.isBlock || nodeAfter.isAtom)) {\n        return { node: nodeAfter, element: blockEl, pos: pos };\n      }\n    }\n  } catch (_e) {\n    // console.warn(_e);\n  }\n\n  return null;\n}\n\nexport const AteBlockControlsExtension = Extension.create<AteBlockControlsOptions>({\n  name: \"ateBlockControls\",\n\n  addOptions() {\n    return { onHover: undefined };\n  },\n\n  addProseMirrorPlugins() {\n    let lastHoveredElement: HTMLElement | null = null;\n    let lastHoveredPos: number | null = null;\n    let rafId: number | null = null;\n    let lastMouseX = 0;\n    let lastMouseY = 0;\n\n    const update = (view: EditorView) => {\n      if (!this.editor.isEditable) {\n        return;\n      }\n\n      const editorRect = view.dom.getBoundingClientRect();\n      const gutterWidth = 80;\n\n      // Check Limites (Marge Gauche + Editeur)\n      if (\n        lastMouseY < editorRect.top ||\n        lastMouseY > editorRect.bottom ||\n        lastMouseX > editorRect.right ||\n        lastMouseX < editorRect.left - gutterWidth\n      ) {\n        if (lastHoveredElement) {\n          reset();\n        }\n        return;\n      }\n\n      // STICKY ANTI-FLICKER\n      // On garde le bloc tant qu'on est dans sa hauteur\n      if (lastHoveredElement && lastHoveredElement.isConnected) {\n        const rect = lastHoveredElement.getBoundingClientRect();\n        if (lastMouseY >= rect.top && lastMouseY <= rect.bottom) {\n          return;\n        }\n      }\n\n      const target = document.elementFromPoint(lastMouseX, lastMouseY) as HTMLElement;\n\n      const data = resolveBlockData(view, lastMouseY, target);\n\n      if (data && (data.element !== lastHoveredElement || data.pos !== lastHoveredPos)) {\n        lastHoveredElement = data.element;\n        lastHoveredPos = data.pos;\n        this.options.onHover?.(data);\n      } else if (!data) {\n        if (!lastHoveredElement || !lastHoveredElement.isConnected) {\n          reset();\n        }\n      }\n    };\n\n    const reset = () => {\n      this.options.onHover?.(null);\n      lastHoveredElement = null;\n      lastHoveredPos = null;\n    };\n\n    return [\n      new Plugin({\n        key: new PluginKey(\"ateBlockControls\"),\n        props: {\n          handleDOMEvents: {\n            mousemove: (view: EditorView, event: MouseEvent) => {\n              lastMouseX = event.clientX;\n              lastMouseY = event.clientY;\n\n              if (rafId === null) {\n                rafId = window.requestAnimationFrame(() => {\n                  update(view);\n                  rafId = null;\n                });\n              }\n              return false;\n            },\n            mouseleave: () => {\n              if (rafId) {\n                window.cancelAnimationFrame(rafId);\n                rafId = null;\n              }\n              reset();\n              return false;\n            },\n          },\n        },\n      }),\n    ];\n  },\n});\n"]}

package/esm2022/lib/extensions/ate-link-click-behavior.extension.mjs

@@ -0,0 +1,32 @@
+import { Extension, getAttributes } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+export const AteLinkClickBehavior = Extension.create({
+    name: "linkClickBehavior",
+    addProseMirrorPlugins() {
+        return [
+            new Plugin({
+                key: new PluginKey("linkClickBehavior"),
+                props: {
+                    handleClick(view, _pos, event) {
+                        // handleClick only runs in the browser, but we guard it for absolute SSR safety
+                        if (typeof window === "undefined") {
+                            return false;
+                        }
+                        const isModKey = event.ctrlKey || event.metaKey;
+                        // If editor is editable, only proceed if Ctrl/Cmd is pressed
+                        if (view.editable && !isModKey) {
+                            return false;
+                        }
+                        const attrs = getAttributes(view.state, "link");
+                        if (attrs["href"]) {
+                            window.open(attrs["href"], "_blank", "noopener,noreferrer");
+                            return true;
+                        }
+                        return false;
+                    },
+                },
+            }),
+        ];
+    },
+});
+//# sourceMappingURL=data:application/json;base64,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