@flogeez/angular-tiptap-editor 2.3.0 → 2.4.1

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

@@ -0,0 +1,368 @@
+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) {
+        const { from } = editor.state.selection;
+        editor.chain().focus().setResizableImage(imageData).setNodeSelection(from).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();
+        }
+    }
+    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 pos = editor.state.selection.from;
+        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)
+                    .setNodeSelection(pos)
+                    .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);
+    }
+    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    const { from } = editor.state.selection;\n    editor.chain().focus().setResizableImage(imageData).setNodeSelection(from).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  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 pos = editor.state.selection.from;\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            .setNodeSelection(pos)\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"]}

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

@@ -0,0 +1,97 @@
+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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

package/esm2022/lib/utils/ate-color.utils.mjs

@@ -0,0 +1,60 @@
+/**
+ * Normalizes color values (rgb/rgba to hex).
+ */
+export function normalizeColor(color) {
+    if (!color || color === "transparent" || color === "rgba(0, 0, 0, 0)") {
+        return null;
+    }
+    if (color.startsWith("#")) {
+        return color;
+    }
+    // Support both comma-separated (legacy) and space-separated (modern) rgb/rgba
+    const rgbMatch = color
+        .trim()
+        .match(/^rgba?\(\s*([\d.]+)[,\s]+([\d.]+)[,\s]+([\d.]+)(?:[,\s/]+([\d.]+))?\s*\)$/i);
+    // If it's a named color or something else we don't recognize,
+    // we can't easily normalize it to hex without a heavy dictionary.
+    // However, getComputedStyle usually returns rgb() which we handle above.
+    if (!rgbMatch) {
+        // Simple fallback for common named colors if getComputedStyle fails to return rgb
+        const named = { black: "#000000", white: "#ffffff", red: "#ff0000" };
+        if (named[color.toLowerCase()]) {
+            return named[color.toLowerCase()];
+        }
+        return null;
+    }
+    const r = Math.max(0, Math.min(255, Math.round(parseFloat(rgbMatch[1]))));
+    const g = Math.max(0, Math.min(255, Math.round(parseFloat(rgbMatch[2]))));
+    const b = Math.max(0, Math.min(255, Math.round(parseFloat(rgbMatch[3]))));
+    const a = rgbMatch[4] ? parseFloat(rgbMatch[4]) : 1;
+    // If completely transparent, return null
+    if (a === 0) {
+        return null;
+    }
+    return ("#" +
+        [r, g, b]
+            .map(n => n.toString(16).padStart(2, "0"))
+            .join("")
+            .toLowerCase());
+}
+/**
+ * Calculate luminance (0-255).
+ */
+export function getLuminance(color) {
+    const normalized = normalizeColor(color);
+    if (!normalized) {
+        return 0;
+    } // Default to dark (luminance 0) if no color
+    const hex = normalized.replace("#", "");
+    const r = parseInt(hex.substring(0, 2), 16);
+    const g = parseInt(hex.substring(2, 4), 16);
+    const b = parseInt(hex.substring(4, 6), 16);
+    return (r * 299 + g * 587 + b * 114) / 1000;
+}
+/**
+ * Returns contrast color for readability.
+ */
+export function getContrastColor(color) {
+    return getLuminance(color) > 128 ? "black" : "white";
+}
+//# sourceMappingURL=data:application/json;base64,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