@flogeez/angular-tiptap-editor 3.1.3 → 3.1.5

package/esm2022/lib/services/ate-image.service.mjs

@@ -0,0 +1,459 @@
+import { Injectable, signal, computed, inject } from "@angular/core";
+import { isObservable, firstValueFrom } from "rxjs";
+import { AteI18nService } from "./ate-i18n.service";
+import * as i0 from "@angular/core";
+export class AteImageService {
+    constructor() {
+        /** Signals for image state */
+        this.selectedImage = signal(null);
+        this.isImageSelected = computed(() => this.selectedImage() !== null);
+        /** Resizing state */
+        this.isResizing = signal(false);
+        this.i18n = inject(AteI18nService);
+        this.t = this.i18n.imageUpload;
+        /** Upload state signals */
+        this.isUploading = signal(false);
+        this.uploadProgress = signal(0);
+        this.uploadMessage = signal("");
+        /**
+         * Custom upload handler.
+         * If set, this handler replaces the default base64 conversion.
+         */
+        this.uploadHandler = null;
+        this.currentEditor = null;
+    }
+    /** Select and track an image from the editor */
+    selectImage(editor) {
+        if (editor.isActive("resizableImage")) {
+            const attrs = editor.getAttributes("resizableImage");
+            this.selectedImage.set({
+                src: attrs["src"],
+                alt: attrs["alt"],
+                title: attrs["title"],
+                width: attrs["width"],
+                height: attrs["height"],
+            });
+        }
+        else {
+            this.selectedImage.set(null);
+        }
+    }
+    clearSelection() {
+        this.selectedImage.set(null);
+    }
+    /** Insert a new image and ensure it's selected */
+    insertImage(editor, imageData) {
+        editor
+            .chain()
+            .focus()
+            .setResizableImage(imageData)
+            .command(({ tr, commands }) => {
+            // Selection is usually after the node. Node is at tr.selection.from - 1.
+            const { from } = tr.selection;
+            // Try to select node at current pos (if it was already selected) or previous pos
+            return commands.setNodeSelection(from) || commands.setNodeSelection(from - 1) || true;
+        })
+            .run();
+    }
+    /** Update attributes of the currently active image */
+    updateImageAttributes(editor, attributes) {
+        if (editor.isActive("resizableImage")) {
+            const pos = editor.state.selection.from;
+            editor
+                .chain()
+                .focus()
+                .updateAttributes("resizableImage", attributes)
+                .setNodeSelection(pos)
+                .run();
+            this.updateSelectedImage(attributes);
+        }
+    }
+    /** Resize image with optional aspect ratio maintenance */
+    resizeImage(editor, options) {
+        if (!editor.isActive("resizableImage")) {
+            return;
+        }
+        const currentAttrs = editor.getAttributes("resizableImage");
+        let newWidth = options.width;
+        let newHeight = options.height;
+        // Maintain aspect ratio if requested
+        if (options.maintainAspectRatio !== false && currentAttrs["width"] && currentAttrs["height"]) {
+            const aspectRatio = currentAttrs["width"] / currentAttrs["height"];
+            if (newWidth && !newHeight) {
+                newHeight = Math.round(newWidth / aspectRatio);
+            }
+            else if (newHeight && !newWidth) {
+                newWidth = Math.round(newHeight * aspectRatio);
+            }
+        }
+        // Apply minimum limits
+        if (newWidth) {
+            newWidth = Math.max(50, newWidth);
+        }
+        if (newHeight) {
+            newHeight = Math.max(50, newHeight);
+        }
+        this.updateImageAttributes(editor, {
+            width: newWidth,
+            height: newHeight,
+        });
+    }
+    /** Predetermined resize helpers used by UI */
+    resizeImageToSmall(editor) {
+        this.resizeImage(editor, { width: 300, height: 200, maintainAspectRatio: true });
+    }
+    resizeImageToMedium(editor) {
+        this.resizeImage(editor, { width: 500, height: 350, maintainAspectRatio: true });
+    }
+    resizeImageToLarge(editor) {
+        this.resizeImage(editor, { width: 800, height: 600, maintainAspectRatio: true });
+    }
+    resizeImageToOriginal(editor) {
+        if (!editor.isActive("resizableImage")) {
+            return;
+        }
+        const img = new Image();
+        img.onload = () => {
+            this.resizeImage(editor, { width: img.naturalWidth, height: img.naturalHeight });
+        };
+        img.src = editor.getAttributes("resizableImage")["src"];
+    }
+    /** Get current image dimensions */
+    getImageDimensions(editor) {
+        if (!editor.isActive("resizableImage")) {
+            return null;
+        }
+        const attrs = editor.getAttributes("resizableImage");
+        return {
+            width: attrs["width"] || 0,
+            height: attrs["height"] || 0,
+        };
+    }
+    /** Remove the selected image */
+    deleteImage(editor) {
+        if (editor.isActive("resizableImage")) {
+            editor.chain().focus().deleteSelection().run();
+            this.clearSelection();
+        }
+    }
+    /** Download the current image */
+    downloadImage(editor) {
+        const attrs = editor.getAttributes("resizableImage");
+        if (!attrs || !attrs["src"]) {
+            return;
+        }
+        const src = attrs["src"];
+        const fileName = attrs["alt"] || "image";
+        // Detect if it's base64 or remote URL
+        if (src.startsWith("data:") ||
+            src.startsWith("blob:") ||
+            src.startsWith(window.location.origin)) {
+            const link = document.createElement("a");
+            link.href = src;
+            link.download = fileName;
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+        }
+        else {
+            // For remote URLs, we try to fetch it to bypass cross-origin restrictions on 'download' attribute
+            fetch(src)
+                .then(response => response.blob())
+                .then(blob => {
+                const url = window.URL.createObjectURL(blob);
+                const link = document.createElement("a");
+                link.href = url;
+                link.download = fileName;
+                document.body.appendChild(link);
+                link.click();
+                document.body.removeChild(link);
+                window.URL.revokeObjectURL(url);
+            })
+                .catch(err => {
+                console.error("Error downloading image:", err);
+                // Fallback to opening in new tab
+                window.open(src, "_blank");
+            });
+        }
+    }
+    updateSelectedImage(attributes) {
+        const current = this.selectedImage();
+        if (current) {
+            this.selectedImage.set({ ...current, ...attributes });
+        }
+    }
+    /** Validate file type and size */
+    validateImage(file, options) {
+        const maxSize = options?.maxSize || 10 * 1024 * 1024;
+        const allowedTypes = options?.allowedTypes || [];
+        if (allowedTypes.length > 0 && !allowedTypes.includes(file.type)) {
+            return { valid: false, error: this.t().invalidFileType };
+        }
+        if (file.size > maxSize) {
+            return {
+                valid: false,
+                error: `${this.t().imageTooLarge} (max ${Math.round(maxSize / 1024 / 1024)}MB)`,
+            };
+        }
+        return { valid: true };
+    }
+    /** Compress and process image on client side */
+    async compressImage(file, quality = 0.8, maxWidth = 1920, maxHeight = 1200) {
+        return new Promise((resolve, reject) => {
+            const canvas = document.createElement("canvas");
+            const ctx = canvas.getContext("2d");
+            const img = new Image();
+            img.onload = () => {
+                if (this.isUploading()) {
+                    this.uploadProgress.set(40);
+                    this.uploadMessage.set(this.t().resizing);
+                }
+                let { width, height } = img;
+                if (width > maxWidth || height > maxHeight) {
+                    const ratio = Math.min(maxWidth / width, maxHeight / height);
+                    width *= ratio;
+                    height *= ratio;
+                }
+                canvas.width = width;
+                canvas.height = height;
+                ctx?.drawImage(img, 0, 0, width, height);
+                if (this.isUploading()) {
+                    this.uploadProgress.set(60);
+                    this.uploadMessage.set(this.t().compressing);
+                }
+                canvas.toBlob(blob => {
+                    if (blob) {
+                        const reader = new FileReader();
+                        reader.onload = e => {
+                            const base64 = e.target?.result;
+                            resolve({
+                                src: base64,
+                                name: file.name,
+                                size: blob.size,
+                                type: file.type,
+                                width: Math.round(width),
+                                height: Math.round(height),
+                                originalSize: file.size,
+                            });
+                        };
+                        reader.readAsDataURL(blob);
+                    }
+                    else {
+                        reject(new Error(this.t().compressionError));
+                    }
+                }, file.type, quality);
+            };
+            img.onerror = () => reject(new Error(this.t().loadError));
+            img.src = URL.createObjectURL(file);
+        });
+    }
+    /** Core upload logic with progress tracking */
+    async uploadImageWithProgress(editor, file, insertionStrategy, actionMessage, options) {
+        try {
+            this.currentEditor = editor;
+            this.isUploading.set(true);
+            this.uploadProgress.set(10);
+            this.uploadMessage.set(this.t().validating);
+            this.forceEditorUpdate();
+            const validation = this.validateImage(file, {
+                maxSize: options?.maxSize,
+                allowedTypes: options?.allowedTypes,
+            });
+            if (!validation.valid) {
+                throw new Error(validation.error);
+            }
+            this.uploadProgress.set(30);
+            this.uploadMessage.set(this.t().compressing);
+            this.forceEditorUpdate();
+            const result = await this.compressImage(file, options?.quality || 0.8, options?.maxWidth || 1920, options?.maxHeight || 1200);
+            this.uploadProgress.set(70);
+            // Handle custom upload if handler is provided
+            if (this.uploadHandler) {
+                this.uploadMessage.set(this.t().uploadingToServer);
+                this.forceEditorUpdate();
+                try {
+                    const handlerResponse = this.uploadHandler({
+                        file,
+                        width: result.width || 0,
+                        height: result.height || 0,
+                        type: result.type,
+                        base64: result.src,
+                    });
+                    const handlerResult = isObservable(handlerResponse)
+                        ? await firstValueFrom(handlerResponse)
+                        : await handlerResponse;
+                    result.src = handlerResult.src;
+                    if (handlerResult.alt) {
+                        result.name = handlerResult.alt;
+                    }
+                }
+                catch (handlerError) {
+                    console.error(this.t().uploadError, handlerError);
+                    throw handlerError;
+                }
+            }
+            this.uploadProgress.set(90);
+            this.uploadMessage.set(actionMessage);
+            this.forceEditorUpdate();
+            // Final insertion
+            insertionStrategy(editor, result);
+            this.resetUploadState();
+        }
+        catch (error) {
+            this.resetUploadState();
+            console.error(this.t().uploadError, error);
+            throw error;
+        }
+    }
+    resetUploadState() {
+        this.isUploading.set(false);
+        this.uploadProgress.set(0);
+        this.uploadMessage.set("");
+        this.forceEditorUpdate();
+        this.currentEditor = null;
+    }
+    /** Main entry point for file upload and insertion */
+    async uploadAndInsertImage(editor, file, options) {
+        return this.uploadImageWithProgress(editor, file, (ed, result) => {
+            this.insertImage(ed, {
+                src: result.src,
+                alt: result.name,
+                title: `${result.name} (${result.width}×${result.height})`,
+                width: result.width,
+                height: result.height,
+            });
+        }, this.t().insertingImage, options);
+    }
+    /** Trigger an editor transaction to force decoration update */
+    forceEditorUpdate() {
+        if (this.currentEditor) {
+            const { tr } = this.currentEditor.state;
+            this.currentEditor.view.dispatch(tr);
+        }
+    }
+    /** Generic helper to open file picker and process selection */
+    async selectFileAndProcess(editor, uploadMethod, options) {
+        return new Promise((resolve, reject) => {
+            const input = document.createElement("input");
+            input.type = "file";
+            // Use allowedTypes if provided, otherwise default to image/*
+            if (options?.allowedTypes && options.allowedTypes.length > 0) {
+                input.accept = options.allowedTypes.join(",");
+            }
+            else {
+                input.accept = "image/*";
+            }
+            input.style.display = "none";
+            input.addEventListener("change", async (e) => {
+                const file = e.target.files?.[0];
+                if (file && file.type.startsWith("image/")) {
+                    try {
+                        await uploadMethod(editor, file, options);
+                        resolve();
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                }
+                else {
+                    reject(new Error(this.t().noFileSelected));
+                }
+                document.body.removeChild(input);
+            });
+            input.addEventListener("cancel", () => {
+                document.body.removeChild(input);
+                reject(new Error(this.t().selectionCancelled));
+            });
+            document.body.appendChild(input);
+            input.click();
+        });
+    }
+    /** Select file and upload as new image */
+    async selectAndUploadImage(editor, options) {
+        return this.selectFileAndProcess(editor, this.uploadAndInsertImage.bind(this), options);
+    }
+    /** Select file and replace currently selected image */
+    async selectAndReplaceImage(editor, options) {
+        // No need for complicated backup/restore now that we don't delete prematurely.
+        // The uploadAndReplaceImage will handle the atomic replacement.
+        return this.selectFileAndProcess(editor, this.uploadAndReplaceImage.bind(this), options);
+    }
+    /** Internal helper used by replacement logic */
+    async uploadAndReplaceImage(editor, file, options) {
+        // Store current position to ensure we can re-select the image even if selection blurs during upload
+        const wasActive = editor.isActive("resizableImage");
+        await this.uploadImageWithProgress(editor, file, (ed, result) => {
+            const imageData = {
+                src: result.src,
+                alt: result.name,
+                title: `${result.name} (${result.width}×${result.height})`,
+                width: result.width,
+                height: result.height,
+            };
+            // If the image was active or is still active, update it atomically
+            if (wasActive || ed.isActive("resizableImage")) {
+                ed.chain()
+                    .focus()
+                    .updateAttributes("resizableImage", imageData)
+                    .command(({ tr, commands }) => {
+                    const { from } = tr.selection;
+                    // Re-select the node at its mapped position or current selection
+                    return commands.setNodeSelection(from) || commands.setNodeSelection(from - 1) || true;
+                })
+                    .run();
+                this.updateSelectedImage(imageData);
+            }
+            else {
+                // Otherwise replace whatever is selected (or insert at cursor)
+                this.insertImage(ed, imageData);
+            }
+            // After replacement, ensure the image is tracked in our signals
+            this.selectImage(ed);
+        }, this.t().replacingImage, options);
+    }
+    /**
+     * Handle image drop event.
+     * Calculates the position from coordinates and sets the selection accordingly.
+     */
+    handleDrop(editor, event, options) {
+        const files = event.dataTransfer?.files;
+        if (!files || files.length === 0) {
+            return false;
+        }
+        const file = Array.from(files).find(f => f.type.startsWith("image/"));
+        if (!file) {
+            return false;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        // Try to find the drop position from coordinates
+        const pos = editor.view.posAtCoords({ left: event.clientX, top: event.clientY });
+        if (pos) {
+            editor.commands.setTextSelection(pos.pos);
+        }
+        void this.uploadAndInsertImage(editor, file, options);
+        return true;
+    }
+    /**
+     * Handle image paste event.
+     */
+    handlePaste(editor, event, options) {
+        const clipboardFiles = event.clipboardData?.files;
+        if (!clipboardFiles || clipboardFiles.length === 0) {
+            return false;
+        }
+        const imageFile = Array.from(clipboardFiles).find(file => file.type.startsWith("image/"));
+        if (!imageFile) {
+            return false;
+        }
+        event.preventDefault();
+        void this.uploadAndInsertImage(editor, imageFile, options);
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteImageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteImageService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteImageService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ate-image.service.js","sourceRoot":"","sources":["../../../../../projects/angular-tiptap-editor/src/lib/services/ate-image.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, signal, computed, inject } from \"@angular/core\";\nimport { Editor } from \"@tiptap/core\";\nimport { isObservable, firstValueFrom } from \"rxjs\";\nimport { AteI18nService } from \"./ate-i18n.service\";\nimport {\n  AteResizeOptions,\n  AteImageUploadOptions,\n  AteImageUploadHandler,\n  AteImageUploadResult,\n  AteImageData,\n} from \"../models/ate-image.model\";\n\n@Injectable()\nexport class AteImageService {\n  /** Signals for image state */\n  selectedImage = signal<AteImageData | null>(null);\n  isImageSelected = computed(() => this.selectedImage() !== null);\n\n  /** Resizing state */\n  isResizing = signal(false);\n\n  private i18n = inject(AteI18nService);\n  private readonly t = this.i18n.imageUpload;\n\n  /** Upload state signals */\n  isUploading = signal(false);\n  uploadProgress = signal(0);\n  uploadMessage = signal(\"\");\n\n  /**\n   * Custom upload handler.\n   * If set, this handler replaces the default base64 conversion.\n   */\n  uploadHandler: AteImageUploadHandler | null = null;\n\n  private currentEditor: Editor | null = null;\n\n  /** Select and track an image from the editor */\n  selectImage(editor: Editor): void {\n    if (editor.isActive(\"resizableImage\")) {\n      const attrs = editor.getAttributes(\"resizableImage\");\n      this.selectedImage.set({\n        src: attrs[\"src\"],\n        alt: attrs[\"alt\"],\n        title: attrs[\"title\"],\n        width: attrs[\"width\"],\n        height: attrs[\"height\"],\n      });\n    } else {\n      this.selectedImage.set(null);\n    }\n  }\n\n  clearSelection(): void {\n    this.selectedImage.set(null);\n  }\n\n  /** Insert a new image and ensure it's selected */\n  insertImage(editor: Editor, imageData: AteImageData): void {\n    editor\n      .chain()\n      .focus()\n      .setResizableImage(imageData)\n      .command(({ tr, commands }) => {\n        // Selection is usually after the node. Node is at tr.selection.from - 1.\n        const { from } = tr.selection;\n        // Try to select node at current pos (if it was already selected) or previous pos\n        return commands.setNodeSelection(from) || commands.setNodeSelection(from - 1) || true;\n      })\n      .run();\n  }\n\n  /** Update attributes of the currently active image */\n  updateImageAttributes(editor: Editor, attributes: Partial<AteImageData>): void {\n    if (editor.isActive(\"resizableImage\")) {\n      const pos = editor.state.selection.from;\n      editor\n        .chain()\n        .focus()\n        .updateAttributes(\"resizableImage\", attributes)\n        .setNodeSelection(pos)\n        .run();\n      this.updateSelectedImage(attributes);\n    }\n  }\n\n  /** Resize image with optional aspect ratio maintenance */\n  resizeImage(editor: Editor, options: AteResizeOptions): void {\n    if (!editor.isActive(\"resizableImage\")) {\n      return;\n    }\n\n    const currentAttrs = editor.getAttributes(\"resizableImage\");\n    let newWidth = options.width;\n    let newHeight = options.height;\n\n    // Maintain aspect ratio if requested\n    if (options.maintainAspectRatio !== false && currentAttrs[\"width\"] && currentAttrs[\"height\"]) {\n      const aspectRatio = currentAttrs[\"width\"] / currentAttrs[\"height\"];\n\n      if (newWidth && !newHeight) {\n        newHeight = Math.round(newWidth / aspectRatio);\n      } else if (newHeight && !newWidth) {\n        newWidth = Math.round(newHeight * aspectRatio);\n      }\n    }\n\n    // Apply minimum limits\n    if (newWidth) {\n      newWidth = Math.max(50, newWidth);\n    }\n    if (newHeight) {\n      newHeight = Math.max(50, newHeight);\n    }\n\n    this.updateImageAttributes(editor, {\n      width: newWidth,\n      height: newHeight,\n    });\n  }\n\n  /** Predetermined resize helpers used by UI */\n  resizeImageToSmall(editor: Editor): void {\n    this.resizeImage(editor, { width: 300, height: 200, maintainAspectRatio: true });\n  }\n\n  resizeImageToMedium(editor: Editor): void {\n    this.resizeImage(editor, { width: 500, height: 350, maintainAspectRatio: true });\n  }\n\n  resizeImageToLarge(editor: Editor): void {\n    this.resizeImage(editor, { width: 800, height: 600, maintainAspectRatio: true });\n  }\n\n  resizeImageToOriginal(editor: Editor): void {\n    if (!editor.isActive(\"resizableImage\")) {\n      return;\n    }\n    const img = new Image();\n    img.onload = () => {\n      this.resizeImage(editor, { width: img.naturalWidth, height: img.naturalHeight });\n    };\n    img.src = editor.getAttributes(\"resizableImage\")[\"src\"];\n  }\n\n  /** Get current image dimensions */\n  getImageDimensions(editor: Editor): { width: number; height: number } | null {\n    if (!editor.isActive(\"resizableImage\")) {\n      return null;\n    }\n    const attrs = editor.getAttributes(\"resizableImage\");\n    return {\n      width: attrs[\"width\"] || 0,\n      height: attrs[\"height\"] || 0,\n    };\n  }\n\n  /** Remove the selected image */\n  deleteImage(editor: Editor): void {\n    if (editor.isActive(\"resizableImage\")) {\n      editor.chain().focus().deleteSelection().run();\n      this.clearSelection();\n    }\n  }\n\n  /** Download the current image */\n  downloadImage(editor: Editor): void {\n    const attrs = editor.getAttributes(\"resizableImage\");\n    if (!attrs || !attrs[\"src\"]) {\n      return;\n    }\n\n    const src = attrs[\"src\"];\n    const fileName = attrs[\"alt\"] || \"image\";\n\n    // Detect if it's base64 or remote URL\n    if (\n      src.startsWith(\"data:\") ||\n      src.startsWith(\"blob:\") ||\n      src.startsWith(window.location.origin)\n    ) {\n      const link = document.createElement(\"a\");\n      link.href = src;\n      link.download = fileName;\n      document.body.appendChild(link);\n      link.click();\n      document.body.removeChild(link);\n    } else {\n      // For remote URLs, we try to fetch it to bypass cross-origin restrictions on 'download' attribute\n      fetch(src)\n        .then(response => response.blob())\n        .then(blob => {\n          const url = window.URL.createObjectURL(blob);\n          const link = document.createElement(\"a\");\n          link.href = url;\n          link.download = fileName;\n          document.body.appendChild(link);\n          link.click();\n          document.body.removeChild(link);\n          window.URL.revokeObjectURL(url);\n        })\n        .catch(err => {\n          console.error(\"Error downloading image:\", err);\n          // Fallback to opening in new tab\n          window.open(src, \"_blank\");\n        });\n    }\n  }\n\n  private updateSelectedImage(attributes: Partial<AteImageData>): void {\n    const current = this.selectedImage();\n    if (current) {\n      this.selectedImage.set({ ...current, ...attributes });\n    }\n  }\n\n  /** Validate file type and size */\n  validateImage(\n    file: File,\n    options?: { maxSize?: number; allowedTypes?: string[] }\n  ): { valid: boolean; error?: string } {\n    const maxSize = options?.maxSize || 10 * 1024 * 1024;\n    const allowedTypes = options?.allowedTypes || [];\n\n    if (allowedTypes.length > 0 && !allowedTypes.includes(file.type)) {\n      return { valid: false, error: this.t().invalidFileType };\n    }\n\n    if (file.size > maxSize) {\n      return {\n        valid: false,\n        error: `${this.t().imageTooLarge} (max ${Math.round(maxSize / 1024 / 1024)}MB)`,\n      };\n    }\n    return { valid: true };\n  }\n\n  /** Compress and process image on client side */\n  async compressImage(\n    file: File,\n    quality = 0.8,\n    maxWidth = 1920,\n    maxHeight = 1200\n  ): Promise<AteImageUploadResult> {\n    return new Promise((resolve, reject) => {\n      const canvas = document.createElement(\"canvas\");\n      const ctx = canvas.getContext(\"2d\");\n      const img = new Image();\n\n      img.onload = () => {\n        if (this.isUploading()) {\n          this.uploadProgress.set(40);\n          this.uploadMessage.set(this.t().resizing);\n        }\n\n        let { width, height } = img;\n        if (width > maxWidth || height > maxHeight) {\n          const ratio = Math.min(maxWidth / width, maxHeight / height);\n          width *= ratio;\n          height *= ratio;\n        }\n\n        canvas.width = width;\n        canvas.height = height;\n        ctx?.drawImage(img, 0, 0, width, height);\n\n        if (this.isUploading()) {\n          this.uploadProgress.set(60);\n          this.uploadMessage.set(this.t().compressing);\n        }\n\n        canvas.toBlob(\n          blob => {\n            if (blob) {\n              const reader = new FileReader();\n              reader.onload = e => {\n                const base64 = e.target?.result as string;\n                resolve({\n                  src: base64,\n                  name: file.name,\n                  size: blob.size,\n                  type: file.type,\n                  width: Math.round(width),\n                  height: Math.round(height),\n                  originalSize: file.size,\n                });\n              };\n              reader.readAsDataURL(blob);\n            } else {\n              reject(new Error(this.t().compressionError));\n            }\n          },\n          file.type,\n          quality\n        );\n      };\n\n      img.onerror = () => reject(new Error(this.t().loadError));\n      img.src = URL.createObjectURL(file);\n    });\n  }\n\n  /** Core upload logic with progress tracking */\n  private async uploadImageWithProgress(\n    editor: Editor,\n    file: File,\n    insertionStrategy: (editor: Editor, result: AteImageUploadResult) => void,\n    actionMessage: string,\n    options?: AteImageUploadOptions\n  ): Promise<void> {\n    try {\n      this.currentEditor = editor;\n      this.isUploading.set(true);\n      this.uploadProgress.set(10);\n      this.uploadMessage.set(this.t().validating);\n      this.forceEditorUpdate();\n\n      const validation = this.validateImage(file, {\n        maxSize: options?.maxSize,\n        allowedTypes: options?.allowedTypes,\n      });\n      if (!validation.valid) {\n        throw new Error(validation.error);\n      }\n\n      this.uploadProgress.set(30);\n      this.uploadMessage.set(this.t().compressing);\n      this.forceEditorUpdate();\n\n      const result = await this.compressImage(\n        file,\n        options?.quality || 0.8,\n        options?.maxWidth || 1920,\n        options?.maxHeight || 1200\n      );\n\n      this.uploadProgress.set(70);\n\n      // Handle custom upload if handler is provided\n      if (this.uploadHandler) {\n        this.uploadMessage.set(this.t().uploadingToServer);\n        this.forceEditorUpdate();\n\n        try {\n          const handlerResponse = this.uploadHandler({\n            file,\n            width: result.width || 0,\n            height: result.height || 0,\n            type: result.type,\n            base64: result.src,\n          });\n\n          const handlerResult = isObservable(handlerResponse)\n            ? await firstValueFrom(handlerResponse)\n            : await handlerResponse;\n\n          result.src = handlerResult.src;\n          if (handlerResult.alt) {\n            result.name = handlerResult.alt;\n          }\n        } catch (handlerError) {\n          console.error(this.t().uploadError, handlerError);\n          throw handlerError;\n        }\n      }\n\n      this.uploadProgress.set(90);\n      this.uploadMessage.set(actionMessage);\n      this.forceEditorUpdate();\n\n      // Final insertion\n      insertionStrategy(editor, result);\n\n      this.resetUploadState();\n    } catch (error) {\n      this.resetUploadState();\n      console.error(this.t().uploadError, error);\n      throw error;\n    }\n  }\n\n  private resetUploadState() {\n    this.isUploading.set(false);\n    this.uploadProgress.set(0);\n    this.uploadMessage.set(\"\");\n    this.forceEditorUpdate();\n    this.currentEditor = null;\n  }\n\n  /** Main entry point for file upload and insertion */\n  async uploadAndInsertImage(\n    editor: Editor,\n    file: File,\n    options?: AteImageUploadOptions\n  ): Promise<void> {\n    return this.uploadImageWithProgress(\n      editor,\n      file,\n      (ed, result) => {\n        this.insertImage(ed, {\n          src: result.src,\n          alt: result.name,\n          title: `${result.name} (${result.width}×${result.height})`,\n          width: result.width,\n          height: result.height,\n        });\n      },\n      this.t().insertingImage,\n      options\n    );\n  }\n\n  /** Trigger an editor transaction to force decoration update */\n  private forceEditorUpdate() {\n    if (this.currentEditor) {\n      const { tr } = this.currentEditor.state;\n      this.currentEditor.view.dispatch(tr);\n    }\n  }\n\n  /** Generic helper to open file picker and process selection */\n  private async selectFileAndProcess(\n    editor: Editor,\n    uploadMethod: (editor: Editor, file: File, options?: AteImageUploadOptions) => Promise<void>,\n    options?: AteImageUploadOptions\n  ): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const input = document.createElement(\"input\");\n      input.type = \"file\";\n\n      // Use allowedTypes if provided, otherwise default to image/*\n      if (options?.allowedTypes && options.allowedTypes.length > 0) {\n        input.accept = options.allowedTypes.join(\",\");\n      } else {\n        input.accept = \"image/*\";\n      }\n\n      input.style.display = \"none\";\n\n      input.addEventListener(\"change\", async e => {\n        const file = (e.target as HTMLInputElement).files?.[0];\n        if (file && file.type.startsWith(\"image/\")) {\n          try {\n            await uploadMethod(editor, file, options);\n            resolve();\n          } catch (error) {\n            reject(error);\n          }\n        } else {\n          reject(new Error(this.t().noFileSelected));\n        }\n        document.body.removeChild(input);\n      });\n\n      input.addEventListener(\"cancel\", () => {\n        document.body.removeChild(input);\n        reject(new Error(this.t().selectionCancelled));\n      });\n\n      document.body.appendChild(input);\n      input.click();\n    });\n  }\n\n  /** Select file and upload as new image */\n  async selectAndUploadImage(editor: Editor, options?: AteImageUploadOptions): Promise<void> {\n    return this.selectFileAndProcess(editor, this.uploadAndInsertImage.bind(this), options);\n  }\n\n  /** Select file and replace currently selected image */\n  async selectAndReplaceImage(editor: Editor, options?: AteImageUploadOptions): Promise<void> {\n    // No need for complicated backup/restore now that we don't delete prematurely.\n    // The uploadAndReplaceImage will handle the atomic replacement.\n    return this.selectFileAndProcess(editor, this.uploadAndReplaceImage.bind(this), options);\n  }\n\n  /** Internal helper used by replacement logic */\n  async uploadAndReplaceImage(\n    editor: Editor,\n    file: File,\n    options?: AteImageUploadOptions\n  ): Promise<void> {\n    // Store current position to ensure we can re-select the image even if selection blurs during upload\n    const wasActive = editor.isActive(\"resizableImage\");\n\n    await this.uploadImageWithProgress(\n      editor,\n      file,\n      (ed, result) => {\n        const imageData = {\n          src: result.src,\n          alt: result.name,\n          title: `${result.name} (${result.width}×${result.height})`,\n          width: result.width,\n          height: result.height,\n        };\n\n        // If the image was active or is still active, update it atomically\n        if (wasActive || ed.isActive(\"resizableImage\")) {\n          ed.chain()\n            .focus()\n            .updateAttributes(\"resizableImage\", imageData)\n            .command(({ tr, commands }) => {\n              const { from } = tr.selection;\n              // Re-select the node at its mapped position or current selection\n              return commands.setNodeSelection(from) || commands.setNodeSelection(from - 1) || true;\n            })\n            .run();\n          this.updateSelectedImage(imageData);\n        } else {\n          // Otherwise replace whatever is selected (or insert at cursor)\n          this.insertImage(ed, imageData);\n        }\n\n        // After replacement, ensure the image is tracked in our signals\n        this.selectImage(ed);\n      },\n      this.t().replacingImage,\n      options\n    );\n  }\n\n  /**\n   * Handle image drop event.\n   * Calculates the position from coordinates and sets the selection accordingly.\n   */\n  handleDrop(editor: Editor, event: DragEvent, options?: AteImageUploadOptions): boolean {\n    const files = event.dataTransfer?.files;\n    if (!files || files.length === 0) {\n      return false;\n    }\n\n    const file = Array.from(files).find(f => f.type.startsWith(\"image/\"));\n    if (!file) {\n      return false;\n    }\n\n    event.preventDefault();\n    event.stopPropagation();\n\n    // Try to find the drop position from coordinates\n    const pos = editor.view.posAtCoords({ left: event.clientX, top: event.clientY });\n    if (pos) {\n      editor.commands.setTextSelection(pos.pos);\n    }\n\n    void this.uploadAndInsertImage(editor, file, options);\n    return true;\n  }\n\n  /**\n   * Handle image paste event.\n   */\n  handlePaste(editor: Editor, event: ClipboardEvent, options?: AteImageUploadOptions): boolean {\n    const clipboardFiles = event.clipboardData?.files;\n    if (!clipboardFiles || clipboardFiles.length === 0) {\n      return false;\n    }\n\n    const imageFile = Array.from(clipboardFiles).find(file => file.type.startsWith(\"image/\"));\n    if (!imageFile) {\n      return false;\n    }\n\n    event.preventDefault();\n    void this.uploadAndInsertImage(editor, imageFile, options);\n    return true;\n  }\n}\n"]}

package/esm2022/lib/services/ate-link.service.mjs

@@ -0,0 +1,99 @@
+import { Injectable, signal } from "@angular/core";
+import * as i0 from "@angular/core";
+export class AteLinkService {
+    constructor() {
+        // ============================================
+        // State Signals (owned by this service)
+        // ============================================
+        /** Whether link edit mode is active */
+        this.editMode = signal(false);
+        /** Reference to the element that triggered the menu (for anchoring) */
+        this.menuTrigger = signal(null);
+        /** Whether the user is currently interacting with the link UI (input focus) */
+        this.isInteracting = signal(false);
+    }
+    // ============================================
+    // Menu Lifecycle Methods
+    // ============================================
+    /**
+     * Open the link edit menu.
+     */
+    open(trigger) {
+        this.menuTrigger.set(trigger || null);
+        this.editMode.set(true);
+    }
+    /**
+     * Close the link edit menu.
+     */
+    close() {
+        this.editMode.set(false);
+        this.isInteracting.set(false);
+    }
+    /**
+     * Final cleanup (called after UI is hidden)
+     */
+    done() {
+        this.menuTrigger.set(null);
+    }
+    /**
+     * Set interaction state
+     */
+    setInteracting(value) {
+        this.isInteracting.set(value);
+    }
+    /**
+     * Toggle link mode from UI.
+     * If a URL string is provided, applies the link and closes.
+     * If an Event is provided, extracts the trigger for anchoring.
+     */
+    toggle(editor, urlOrEvent) {
+        if (!editor) {
+            return;
+        }
+        // If a string URL is provided, set the link and close
+        if (urlOrEvent && typeof urlOrEvent === "string") {
+            this.setLink(editor, urlOrEvent);
+            return;
+        }
+        // If an Event is provided, extract the trigger element
+        let trigger;
+        if (urlOrEvent && typeof urlOrEvent !== "string") {
+            const target = urlOrEvent.target;
+            trigger =
+                urlOrEvent.currentTarget ||
+                    target?.closest("button") ||
+                    target;
+        }
+        // Open the edit menu
+        this.open(trigger);
+    }
+    // ============================================
+    // Link Commands
+    // ============================================
+    /**
+     * Apply a link to the current selection.
+     */
+    setLink(editor, url) {
+        if (!editor) {
+            return;
+        }
+        editor.chain().focus().extendMarkRange("link").setLink({ href: url }).run();
+        this.close();
+    }
+    /**
+     * Remove link from the current selection.
+     */
+    unsetLink(editor) {
+        if (!editor) {
+            return;
+        }
+        editor.chain().focus().extendMarkRange("link").unsetLink().run();
+        this.close();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteLinkService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteLinkService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteLinkService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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