@flogeez/angular-tiptap-editor 2.4.0 → 2.4.1

package/esm2022/lib/components/bubble-menus/text/ate-bubble-menu.component.mjs

@@ -0,0 +1,294 @@
+import { Component, input, ChangeDetectionStrategy, computed, } from "@angular/core";
+import { AteButtonComponent } from "../../ui/ate-button.component";
+import { AteColorPickerComponent } from "../../color-picker/ate-color-picker.component";
+import { AteBaseBubbleMenu } from "../base/ate-base-bubble-menu";
+import * as i0 from "@angular/core";
+export class AteBubbleMenuComponent extends AteBaseBubbleMenu {
+    constructor() {
+        super(...arguments);
+        this.t = this.i18nService.bubbleMenu;
+        this.onMouseDown = () => {
+            this.hideTippy();
+        };
+        this.config = input({
+            bold: true,
+            italic: true,
+            underline: true,
+            strike: true,
+            code: true,
+            superscript: false,
+            subscript: false,
+            highlight: true,
+            textColor: false,
+            link: true,
+            separator: true,
+        });
+        this.bubbleMenuConfig = computed(() => ({
+            bold: true,
+            italic: true,
+            underline: true,
+            strike: true,
+            code: true,
+            superscript: false,
+            subscript: false,
+            highlight: true,
+            textColor: false,
+            link: true,
+            separator: true,
+            ...this.config(),
+        }));
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        const ed = this.editor();
+        // Specialized mousedown listener for the text bubble menu:
+        // This is necessary to hide the menu immediately when clicking elsewhere,
+        // avoiding a 'jumping' effect where the menu moves to the new cursor position
+        // before the reactive state has time to hide it.
+        if (ed?.view?.dom) {
+            ed.view.dom.addEventListener("mousedown", this.onMouseDown, { capture: true });
+        }
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        const ed = this.editor();
+        if (ed?.view?.dom) {
+            ed.view.dom.removeEventListener("mousedown", this.onMouseDown, { capture: true });
+        }
+    }
+    shouldShow() {
+        const { selection, nodes, isEditable, isFocused } = this.state();
+        if (!isEditable) {
+            return false;
+        }
+        // PRIORITY: If we are editing a link or color, HIDE this main bubble menu
+        // to give full priority to the specialized sub-menus.
+        if (this.editorCommands.linkEditMode() || this.editorCommands.colorEditMode()) {
+            return false;
+        }
+        // Now we can check focus for the standard text selection menu
+        if (!isFocused) {
+            return false;
+        }
+        // Only show text bubble menu if there is a non-empty text selection
+        // and no higher-priority node (image, table) is selected.
+        return (selection.type === "text" && !selection.empty && !nodes.isImage && !nodes.isTableNodeSelected);
+    }
+    getSelectionRect() {
+        return this.getRectForSelection(this.editor());
+    }
+    executeCommand(editor, command, ...args) {
+        this.editorCommands.execute(editor, command, ...args);
+    }
+    onTippyHide() {
+        // Sub-menus now manage their own state. Clearing them here causes
+        // premature closing when clicking between 'sibling' menu instances.
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteBubbleMenuComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: AteBubbleMenuComponent, isStandalone: true, selector: "ate-bubble-menu", inputs: { config: { classPropertyName: "config", publicName: "config", isSignal: true, isRequired: false, transformFunction: null } }, usesInheritance: true, ngImport: i0, template: `
+    <div #menuRef class="bubble-menu" (mousedown)="$event.preventDefault()">
+      @if (bubbleMenuConfig().bold) {
+        <ate-button
+          icon="format_bold"
+          [title]="t().bold"
+          [active]="state().marks.bold"
+          [disabled]="!state().can.toggleBold"
+          (buttonClick)="onCommand('toggleBold', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().italic) {
+        <ate-button
+          icon="format_italic"
+          [title]="t().italic"
+          [active]="state().marks.italic"
+          [disabled]="!state().can.toggleItalic"
+          (buttonClick)="onCommand('toggleItalic', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().underline) {
+        <ate-button
+          icon="format_underlined"
+          [title]="t().underline"
+          [active]="state().marks.underline"
+          [disabled]="!state().can.toggleUnderline"
+          (buttonClick)="onCommand('toggleUnderline', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().strike) {
+        <ate-button
+          icon="strikethrough_s"
+          [title]="t().strike"
+          [active]="state().marks.strike"
+          [disabled]="!state().can.toggleStrike"
+          (buttonClick)="onCommand('toggleStrike', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().code) {
+        <ate-button
+          icon="code"
+          [title]="t().code"
+          [active]="state().marks.code"
+          [disabled]="!state().can.toggleCode"
+          (buttonClick)="onCommand('toggleCode', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().superscript) {
+        <ate-button
+          icon="superscript"
+          [title]="t().superscript"
+          [active]="state().marks.superscript"
+          [disabled]="!state().can.toggleSuperscript"
+          (buttonClick)="onCommand('toggleSuperscript', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().subscript) {
+        <ate-button
+          icon="subscript"
+          [title]="t().subscript"
+          [active]="state().marks.subscript"
+          [disabled]="!state().can.toggleSubscript"
+          (buttonClick)="onCommand('toggleSubscript', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().highlight) {
+        <ate-button
+          icon="highlight"
+          [title]="t().highlight"
+          [active]="state().marks.highlight"
+          [disabled]="!state().can.toggleHighlight"
+          (buttonClick)="onCommand('toggleHighlight', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().highlightPicker) {
+        <ate-color-picker
+          mode="highlight"
+          [editor]="editor()"
+          [disabled]="!state().can.setHighlight"
+          [anchorToText]="true" />
+      }
+      @if (bubbleMenuConfig().textColor) {
+        <ate-color-picker
+          mode="text"
+          [editor]="editor()"
+          [disabled]="!state().can.setColor"
+          [anchorToText]="true" />
+      }
+      @if (bubbleMenuConfig().link) {
+        <ate-button
+          icon="link"
+          [title]="t().link"
+          [active]="state().marks.link"
+          [disabled]="!state().can.toggleLink"
+          (buttonClick)="onCommand('toggleLink', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().custom?.length) {
+        @for (item of bubbleMenuConfig().custom; track item.key) {
+          <ate-button
+            [icon]="item.icon"
+            [title]="item.label"
+            (buttonClick)="item.command(editor())"></ate-button>
+        }
+      }
+    </div>
+  `, isInline: true, dependencies: [{ kind: "component", type: AteButtonComponent, selector: "ate-button", inputs: ["icon", "title", "active", "disabled", "color", "backgroundColor", "variant", "size", "iconSize"], outputs: ["buttonClick"] }, { kind: "component", type: AteColorPickerComponent, selector: "ate-color-picker", inputs: ["editor", "mode", "disabled", "anchorToText"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteBubbleMenuComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "ate-bubble-menu",
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [AteButtonComponent, AteColorPickerComponent],
+                    template: `
+    <div #menuRef class="bubble-menu" (mousedown)="$event.preventDefault()">
+      @if (bubbleMenuConfig().bold) {
+        <ate-button
+          icon="format_bold"
+          [title]="t().bold"
+          [active]="state().marks.bold"
+          [disabled]="!state().can.toggleBold"
+          (buttonClick)="onCommand('toggleBold', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().italic) {
+        <ate-button
+          icon="format_italic"
+          [title]="t().italic"
+          [active]="state().marks.italic"
+          [disabled]="!state().can.toggleItalic"
+          (buttonClick)="onCommand('toggleItalic', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().underline) {
+        <ate-button
+          icon="format_underlined"
+          [title]="t().underline"
+          [active]="state().marks.underline"
+          [disabled]="!state().can.toggleUnderline"
+          (buttonClick)="onCommand('toggleUnderline', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().strike) {
+        <ate-button
+          icon="strikethrough_s"
+          [title]="t().strike"
+          [active]="state().marks.strike"
+          [disabled]="!state().can.toggleStrike"
+          (buttonClick)="onCommand('toggleStrike', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().code) {
+        <ate-button
+          icon="code"
+          [title]="t().code"
+          [active]="state().marks.code"
+          [disabled]="!state().can.toggleCode"
+          (buttonClick)="onCommand('toggleCode', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().superscript) {
+        <ate-button
+          icon="superscript"
+          [title]="t().superscript"
+          [active]="state().marks.superscript"
+          [disabled]="!state().can.toggleSuperscript"
+          (buttonClick)="onCommand('toggleSuperscript', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().subscript) {
+        <ate-button
+          icon="subscript"
+          [title]="t().subscript"
+          [active]="state().marks.subscript"
+          [disabled]="!state().can.toggleSubscript"
+          (buttonClick)="onCommand('toggleSubscript', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().highlight) {
+        <ate-button
+          icon="highlight"
+          [title]="t().highlight"
+          [active]="state().marks.highlight"
+          [disabled]="!state().can.toggleHighlight"
+          (buttonClick)="onCommand('toggleHighlight', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().highlightPicker) {
+        <ate-color-picker
+          mode="highlight"
+          [editor]="editor()"
+          [disabled]="!state().can.setHighlight"
+          [anchorToText]="true" />
+      }
+      @if (bubbleMenuConfig().textColor) {
+        <ate-color-picker
+          mode="text"
+          [editor]="editor()"
+          [disabled]="!state().can.setColor"
+          [anchorToText]="true" />
+      }
+      @if (bubbleMenuConfig().link) {
+        <ate-button
+          icon="link"
+          [title]="t().link"
+          [active]="state().marks.link"
+          [disabled]="!state().can.toggleLink"
+          (buttonClick)="onCommand('toggleLink', $event)"></ate-button>
+      }
+      @if (bubbleMenuConfig().custom?.length) {
+        @for (item of bubbleMenuConfig().custom; track item.key) {
+          <ate-button
+            [icon]="item.icon"
+            [title]="item.label"
+            (buttonClick)="item.command(editor())"></ate-button>
+        }
+      }
+    </div>
+  `,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ate-bubble-menu.component.js","sourceRoot":"","sources":["../../../../../../../projects/angular-tiptap-editor/src/lib/components/bubble-menus/text/ate-bubble-menu.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  input,\n  ChangeDetectionStrategy,\n  computed,\n  OnInit,\n  OnDestroy,\n} from \"@angular/core\";\nimport { type Editor } from \"@tiptap/core\";\nimport { AteButtonComponent } from \"../../ui/ate-button.component\";\nimport { AteColorPickerComponent } from \"../../color-picker/ate-color-picker.component\";\nimport { AteBubbleMenuConfig } from \"../../../models/ate-bubble-menu.model\";\nimport { AteBaseBubbleMenu } from \"../base/ate-base-bubble-menu\";\n\n@Component({\n  selector: \"ate-bubble-menu\",\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [AteButtonComponent, AteColorPickerComponent],\n  template: `\n    <div #menuRef class=\"bubble-menu\" (mousedown)=\"$event.preventDefault()\">\n      @if (bubbleMenuConfig().bold) {\n        <ate-button\n          icon=\"format_bold\"\n          [title]=\"t().bold\"\n          [active]=\"state().marks.bold\"\n          [disabled]=\"!state().can.toggleBold\"\n          (buttonClick)=\"onCommand('toggleBold', $event)\"></ate-button>\n      }\n      @if (bubbleMenuConfig().italic) {\n        <ate-button\n          icon=\"format_italic\"\n          [title]=\"t().italic\"\n          [active]=\"state().marks.italic\"\n          [disabled]=\"!state().can.toggleItalic\"\n          (buttonClick)=\"onCommand('toggleItalic', $event)\"></ate-button>\n      }\n      @if (bubbleMenuConfig().underline) {\n        <ate-button\n          icon=\"format_underlined\"\n          [title]=\"t().underline\"\n          [active]=\"state().marks.underline\"\n          [disabled]=\"!state().can.toggleUnderline\"\n          (buttonClick)=\"onCommand('toggleUnderline', $event)\"></ate-button>\n      }\n      @if (bubbleMenuConfig().strike) {\n        <ate-button\n          icon=\"strikethrough_s\"\n          [title]=\"t().strike\"\n          [active]=\"state().marks.strike\"\n          [disabled]=\"!state().can.toggleStrike\"\n          (buttonClick)=\"onCommand('toggleStrike', $event)\"></ate-button>\n      }\n      @if (bubbleMenuConfig().code) {\n        <ate-button\n          icon=\"code\"\n          [title]=\"t().code\"\n          [active]=\"state().marks.code\"\n          [disabled]=\"!state().can.toggleCode\"\n          (buttonClick)=\"onCommand('toggleCode', $event)\"></ate-button>\n      }\n      @if (bubbleMenuConfig().superscript) {\n        <ate-button\n          icon=\"superscript\"\n          [title]=\"t().superscript\"\n          [active]=\"state().marks.superscript\"\n          [disabled]=\"!state().can.toggleSuperscript\"\n          (buttonClick)=\"onCommand('toggleSuperscript', $event)\"></ate-button>\n      }\n      @if (bubbleMenuConfig().subscript) {\n        <ate-button\n          icon=\"subscript\"\n          [title]=\"t().subscript\"\n          [active]=\"state().marks.subscript\"\n          [disabled]=\"!state().can.toggleSubscript\"\n          (buttonClick)=\"onCommand('toggleSubscript', $event)\"></ate-button>\n      }\n      @if (bubbleMenuConfig().highlight) {\n        <ate-button\n          icon=\"highlight\"\n          [title]=\"t().highlight\"\n          [active]=\"state().marks.highlight\"\n          [disabled]=\"!state().can.toggleHighlight\"\n          (buttonClick)=\"onCommand('toggleHighlight', $event)\"></ate-button>\n      }\n      @if (bubbleMenuConfig().highlightPicker) {\n        <ate-color-picker\n          mode=\"highlight\"\n          [editor]=\"editor()\"\n          [disabled]=\"!state().can.setHighlight\"\n          [anchorToText]=\"true\" />\n      }\n      @if (bubbleMenuConfig().textColor) {\n        <ate-color-picker\n          mode=\"text\"\n          [editor]=\"editor()\"\n          [disabled]=\"!state().can.setColor\"\n          [anchorToText]=\"true\" />\n      }\n      @if (bubbleMenuConfig().link) {\n        <ate-button\n          icon=\"link\"\n          [title]=\"t().link\"\n          [active]=\"state().marks.link\"\n          [disabled]=\"!state().can.toggleLink\"\n          (buttonClick)=\"onCommand('toggleLink', $event)\"></ate-button>\n      }\n      @if (bubbleMenuConfig().custom?.length) {\n        @for (item of bubbleMenuConfig().custom; track item.key) {\n          <ate-button\n            [icon]=\"item.icon\"\n            [title]=\"item.label\"\n            (buttonClick)=\"item.command(editor())\"></ate-button>\n        }\n      }\n    </div>\n  `,\n})\nexport class AteBubbleMenuComponent extends AteBaseBubbleMenu implements OnInit, OnDestroy {\n  readonly t = this.i18nService.bubbleMenu;\n\n  override ngOnInit() {\n    super.ngOnInit();\n    const ed = this.editor();\n    // Specialized mousedown listener for the text bubble menu:\n    // This is necessary to hide the menu immediately when clicking elsewhere,\n    // avoiding a 'jumping' effect where the menu moves to the new cursor position\n    // before the reactive state has time to hide it.\n    if (ed?.view?.dom) {\n      ed.view.dom.addEventListener(\"mousedown\", this.onMouseDown, { capture: true });\n    }\n  }\n\n  override ngOnDestroy() {\n    super.ngOnDestroy();\n    const ed = this.editor();\n    if (ed?.view?.dom) {\n      ed.view.dom.removeEventListener(\"mousedown\", this.onMouseDown, { capture: true });\n    }\n  }\n\n  private onMouseDown = () => {\n    this.hideTippy();\n  };\n\n  config = input<AteBubbleMenuConfig>({\n    bold: true,\n    italic: true,\n    underline: true,\n    strike: true,\n    code: true,\n    superscript: false,\n    subscript: false,\n    highlight: true,\n    textColor: false,\n    link: true,\n    separator: true,\n  });\n\n  bubbleMenuConfig = computed(() => ({\n    bold: true,\n    italic: true,\n    underline: true,\n    strike: true,\n    code: true,\n    superscript: false,\n    subscript: false,\n    highlight: true,\n    textColor: false,\n    link: true,\n    separator: true,\n    ...this.config(),\n  }));\n\n  override shouldShow(): boolean {\n    const { selection, nodes, isEditable, isFocused } = this.state();\n\n    if (!isEditable) {\n      return false;\n    }\n\n    // PRIORITY: If we are editing a link or color, HIDE this main bubble menu\n    // to give full priority to the specialized sub-menus.\n    if (this.editorCommands.linkEditMode() || this.editorCommands.colorEditMode()) {\n      return false;\n    }\n\n    // Now we can check focus for the standard text selection menu\n    if (!isFocused) {\n      return false;\n    }\n\n    // Only show text bubble menu if there is a non-empty text selection\n    // and no higher-priority node (image, table) is selected.\n    return (\n      selection.type === \"text\" && !selection.empty && !nodes.isImage && !nodes.isTableNodeSelected\n    );\n  }\n\n  override getSelectionRect(): DOMRect {\n    return this.getRectForSelection(this.editor());\n  }\n\n  protected override executeCommand(editor: Editor, command: string, ...args: unknown[]): void {\n    this.editorCommands.execute(editor, command, ...args);\n  }\n\n  protected override onTippyHide() {\n    // Sub-menus now manage their own state. Clearing them here causes\n    // premature closing when clicking between 'sibling' menu instances.\n  }\n}\n"]}

package/esm2022/lib/components/color-picker/ate-color-picker.component.mjs

@@ -0,0 +1,122 @@
+import { Component, computed, inject, input, ChangeDetectionStrategy } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { AteColorPickerService } from "../../services/ate-color-picker.service";
+import { AteButtonComponent } from "../ui/ate-button.component";
+import { AteI18nService } from "../../services/ate-i18n.service";
+import { AteEditorCommandsService } from "../../services/ate-editor-commands.service";
+import * as i0 from "@angular/core";
+export class AteColorPickerComponent {
+    constructor() {
+        this.editor = input.required();
+        this.mode = input("text");
+        this.disabled = input(false);
+        this.anchorToText = input(false);
+        this.colorPickerSvc = inject(AteColorPickerService);
+        this.i18nService = inject(AteI18nService);
+        this.editorCommands = inject(AteEditorCommandsService);
+        this.t = this.i18nService.toolbar;
+        this.state = this.editorCommands.editorState;
+        this.currentColor = computed(() => {
+            const marks = this.state().marks;
+            const color = this.mode() === "text" ? marks.computedColor : marks.computedBackground;
+            return color || (this.mode() === "text" ? "#000000" : "#ffff00");
+        });
+        this.hasColorApplied = computed(() => {
+            const marks = this.state().marks;
+            return (this.mode() === "text" ? marks.color : marks.background) !== null;
+        });
+        this.buttonIcon = computed(() => {
+            return this.mode() === "text" ? "format_color_text" : "format_color_fill";
+        });
+        this.buttonBgColor = computed(() => {
+            const color = this.currentColor();
+            if (this.mode() === "highlight") {
+                return this.hasColorApplied() ? color : "";
+            }
+            // For text mode, add contrast background if current color is too light
+            if (this.colorPickerSvc.getLuminance(color) > 200) {
+                return "#030617";
+            }
+            return "";
+        });
+        this.buttonTextColor = computed(() => {
+            const color = this.currentColor();
+            if (this.mode() === "text") {
+                return color;
+            }
+            if (this.hasColorApplied()) {
+                return this.colorPickerSvc.getLuminance(color) > 128 ? "#000000" : "#ffffff";
+            }
+            return "var(--ate-text-secondary)";
+        });
+    }
+    onToggle(event) {
+        // If anchorToText is true, we don't pass the event so it defaults to text selection anchoring
+        this.colorPickerSvc.toggle(this.editor(), this.mode(), this.anchorToText() ? undefined : event);
+    }
+    onClear(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        const editor = this.editor();
+        if (this.mode() === "text") {
+            this.colorPickerSvc.unsetColor(editor);
+        }
+        else {
+            this.colorPickerSvc.unsetHighlight(editor);
+        }
+        this.colorPickerSvc.close();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteColorPickerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: AteColorPickerComponent, isStandalone: true, selector: "ate-color-picker", inputs: { editor: { classPropertyName: "editor", publicName: "editor", isSignal: true, isRequired: true, transformFunction: null }, mode: { classPropertyName: "mode", publicName: "mode", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, anchorToText: { classPropertyName: "anchorToText", publicName: "anchorToText", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+    <div class="color-picker-wrapper">
+      <div class="color-picker-container" [class.is-highlight]="mode() === 'highlight'">
+        <ate-button
+          [icon]="buttonIcon()"
+          [title]="mode() === 'text' ? t().textColor : t().highlight"
+          [color]="buttonTextColor()"
+          [backgroundColor]="buttonBgColor()"
+          [disabled]="disabled() || !state().isEditable"
+          (buttonClick)="onToggle($event)" />
+
+        @if (hasColorApplied()) {
+          <button
+            class="btn-clear-badge"
+            type="button"
+            [title]="t().clear"
+            [attr.aria-label]="t().clear"
+            (click)="onClear($event)">
+            <span class="material-symbols-outlined">close</span>
+          </button>
+        }
+      </div>
+    </div>
+  `, isInline: true, styles: [".color-picker-wrapper{position:relative;display:inline-block}.color-picker-container{position:relative;display:inline-flex;align-items:center}.btn-clear-badge{position:absolute;top:-4px;right:-4px;width:14px;height:14px;padding:0;border:none;border-radius:999px;background:#0f172abf;color:#fff;display:flex;align-items:center;justify-content:center;z-index:10;opacity:0;pointer-events:none;transition:opacity .12s ease}.color-picker-container:hover .btn-clear-badge{opacity:1;pointer-events:auto}.btn-clear-badge .material-symbols-outlined{font-size:10px;line-height:1}\n"], dependencies: [{ kind: "component", type: AteButtonComponent, selector: "ate-button", inputs: ["icon", "title", "active", "disabled", "color", "backgroundColor", "variant", "size", "iconSize"], outputs: ["buttonClick"] }, { kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteColorPickerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "ate-color-picker", standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, imports: [AteButtonComponent, CommonModule], template: `
+    <div class="color-picker-wrapper">
+      <div class="color-picker-container" [class.is-highlight]="mode() === 'highlight'">
+        <ate-button
+          [icon]="buttonIcon()"
+          [title]="mode() === 'text' ? t().textColor : t().highlight"
+          [color]="buttonTextColor()"
+          [backgroundColor]="buttonBgColor()"
+          [disabled]="disabled() || !state().isEditable"
+          (buttonClick)="onToggle($event)" />
+
+        @if (hasColorApplied()) {
+          <button
+            class="btn-clear-badge"
+            type="button"
+            [title]="t().clear"
+            [attr.aria-label]="t().clear"
+            (click)="onClear($event)">
+            <span class="material-symbols-outlined">close</span>
+          </button>
+        }
+      </div>
+    </div>
+  `, styles: [".color-picker-wrapper{position:relative;display:inline-block}.color-picker-container{position:relative;display:inline-flex;align-items:center}.btn-clear-badge{position:absolute;top:-4px;right:-4px;width:14px;height:14px;padding:0;border:none;border-radius:999px;background:#0f172abf;color:#fff;display:flex;align-items:center;justify-content:center;z-index:10;opacity:0;pointer-events:none;transition:opacity .12s ease}.color-picker-container:hover .btn-clear-badge{opacity:1;pointer-events:auto}.btn-clear-badge .material-symbols-outlined{font-size:10px;line-height:1}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ate-color-picker.component.js","sourceRoot":"","sources":["../../../../../../projects/angular-tiptap-editor/src/lib/components/color-picker/ate-color-picker.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAC5F,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;;AA8EtF,MAAM,OAAO,uBAAuB;IA1EpC;QA2EE,WAAM,GAAG,KAAK,CAAC,QAAQ,EAAU,CAAC;QAClC,SAAI,GAAG,KAAK,CAAkB,MAAM,CAAC,CAAC;QACtC,aAAQ,GAAG,KAAK,CAAU,KAAK,CAAC,CAAC;QACjC,iBAAY,GAAG,KAAK,CAAU,KAAK,CAAC,CAAC;QAE7B,mBAAc,GAAG,MAAM,CAAC,qBAAqB,CAAC,CAAC;QAC/C,gBAAW,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;QACrC,mBAAc,GAAG,MAAM,CAAC,wBAAwB,CAAC,CAAC;QAEjD,MAAC,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;QAC7B,UAAK,GAAG,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC;QAExC,iBAAY,GAAG,QAAQ,CAAC,GAAG,EAAE;YACpC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC;YACjC,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,EAAE,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC;YACtF,OAAO,KAAK,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QACnE,CAAC,CAAC,CAAC;QAEM,oBAAe,GAAG,QAAQ,CAAC,GAAG,EAAE;YACvC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC;YACjC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;QAC5E,CAAC,CAAC,CAAC;QAEM,eAAU,GAAG,QAAQ,CAAC,GAAG,EAAE;YAClC,OAAO,IAAI,CAAC,IAAI,EAAE,KAAK,MAAM,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,mBAAmB,CAAC;QAC5E,CAAC,CAAC,CAAC;QAEM,kBAAa,GAAG,QAAQ,CAAC,GAAG,EAAE;YACrC,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;YAClC,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,WAAW,EAAE,CAAC;gBAChC,OAAO,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;YAC7C,CAAC;YACD,uEAAuE;YACvE,IAAI,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,GAAG,EAAE,CAAC;gBAClD,OAAO,SAAS,CAAC;YACnB,CAAC;YACD,OAAO,EAAE,CAAC;QACZ,CAAC,CAAC,CAAC;QAEM,oBAAe,GAAG,QAAQ,CAAC,GAAG,EAAE;YACvC,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;YAClC,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,MAAM,EAAE,CAAC;gBAC3B,OAAO,KAAK,CAAC;YACf,CAAC;YACD,IAAI,IAAI,CAAC,eAAe,EAAE,EAAE,CAAC;gBAC3B,OAAO,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;YAC/E,CAAC;YACD,OAAO,2BAA2B,CAAC;QACrC,CAAC,CAAC,CAAC;KAoBJ;IAlBC,QAAQ,CAAC,KAAY;QACnB,8FAA8F;QAC9F,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAClG,CAAC;IAED,OAAO,CAAC,KAAiB;QACvB,KAAK,CAAC,cAAc,EAAE,CAAC;QACvB,KAAK,CAAC,eAAe,EAAE,CAAC;QAExB,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAC7B,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,MAAM,EAAE,CAAC;YAC3B,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACzC,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QAC7C,CAAC;QAED,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;IAC9B,CAAC;+GApEU,uBAAuB;mGAAvB,uBAAuB,qlBArExB;;;;;;;;;;;;;;;;;;;;;;;GAuBT,qoBAxBS,kBAAkB,4LAAE,YAAY;;4FAsE/B,uBAAuB;kBA1EnC,SAAS;+BACE,kBAAkB,cAChB,IAAI,mBACC,uBAAuB,CAAC,MAAM,WACtC,CAAC,kBAAkB,EAAE,YAAY,CAAC,YACjC;;;;;;;;;;;;;;;;;;;;;;;GAuBT","sourcesContent":["import { Component, computed, inject, input, ChangeDetectionStrategy } from \"@angular/core\";\nimport { CommonModule } from \"@angular/common\";\nimport type { Editor } from \"@tiptap/core\";\nimport { AteColorPickerService } from \"../../services/ate-color-picker.service\";\nimport { AteButtonComponent } from \"../ui/ate-button.component\";\nimport { AteI18nService } from \"../../services/ate-i18n.service\";\nimport { AteEditorCommandsService } from \"../../services/ate-editor-commands.service\";\n\nexport type ColorPickerMode = \"text\" | \"highlight\";\n\n@Component({\n  selector: \"ate-color-picker\",\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [AteButtonComponent, CommonModule],\n  template: `\n    <div class=\"color-picker-wrapper\">\n      <div class=\"color-picker-container\" [class.is-highlight]=\"mode() === 'highlight'\">\n        <ate-button\n          [icon]=\"buttonIcon()\"\n          [title]=\"mode() === 'text' ? t().textColor : t().highlight\"\n          [color]=\"buttonTextColor()\"\n          [backgroundColor]=\"buttonBgColor()\"\n          [disabled]=\"disabled() || !state().isEditable\"\n          (buttonClick)=\"onToggle($event)\" />\n\n        @if (hasColorApplied()) {\n          <button\n            class=\"btn-clear-badge\"\n            type=\"button\"\n            [title]=\"t().clear\"\n            [attr.aria-label]=\"t().clear\"\n            (click)=\"onClear($event)\">\n            <span class=\"material-symbols-outlined\">close</span>\n          </button>\n        }\n      </div>\n    </div>\n  `,\n  styles: [\n    `\n      .color-picker-wrapper {\n        position: relative;\n        display: inline-block;\n      }\n\n      .color-picker-container {\n        position: relative;\n        display: inline-flex;\n        align-items: center;\n      }\n\n      .btn-clear-badge {\n        position: absolute;\n        top: -4px;\n        right: -4px;\n        width: 14px;\n        height: 14px;\n        padding: 0;\n        border: none;\n        border-radius: 999px;\n        background: rgba(15, 23, 42, 0.75);\n        color: #ffffff;\n        display: flex;\n        align-items: center;\n        justify-content: center;\n        z-index: 10;\n        opacity: 0;\n        pointer-events: none;\n        transition: opacity 120ms ease;\n      }\n\n      .color-picker-container:hover .btn-clear-badge {\n        opacity: 1;\n        pointer-events: auto;\n      }\n\n      .btn-clear-badge .material-symbols-outlined {\n        font-size: 10px;\n        line-height: 1;\n      }\n    `,\n  ],\n})\nexport class AteColorPickerComponent {\n  editor = input.required<Editor>();\n  mode = input<ColorPickerMode>(\"text\");\n  disabled = input<boolean>(false);\n  anchorToText = input<boolean>(false);\n\n  private colorPickerSvc = inject(AteColorPickerService);\n  private i18nService = inject(AteI18nService);\n  private editorCommands = inject(AteEditorCommandsService);\n\n  readonly t = this.i18nService.toolbar;\n  readonly state = this.editorCommands.editorState;\n\n  readonly currentColor = computed(() => {\n    const marks = this.state().marks;\n    const color = this.mode() === \"text\" ? marks.computedColor : marks.computedBackground;\n    return color || (this.mode() === \"text\" ? \"#000000\" : \"#ffff00\");\n  });\n\n  readonly hasColorApplied = computed(() => {\n    const marks = this.state().marks;\n    return (this.mode() === \"text\" ? marks.color : marks.background) !== null;\n  });\n\n  readonly buttonIcon = computed(() => {\n    return this.mode() === \"text\" ? \"format_color_text\" : \"format_color_fill\";\n  });\n\n  readonly buttonBgColor = computed(() => {\n    const color = this.currentColor();\n    if (this.mode() === \"highlight\") {\n      return this.hasColorApplied() ? color : \"\";\n    }\n    // For text mode, add contrast background if current color is too light\n    if (this.colorPickerSvc.getLuminance(color) > 200) {\n      return \"#030617\";\n    }\n    return \"\";\n  });\n\n  readonly buttonTextColor = computed(() => {\n    const color = this.currentColor();\n    if (this.mode() === \"text\") {\n      return color;\n    }\n    if (this.hasColorApplied()) {\n      return this.colorPickerSvc.getLuminance(color) > 128 ? \"#000000\" : \"#ffffff\";\n    }\n    return \"var(--ate-text-secondary)\";\n  });\n\n  onToggle(event: Event) {\n    // If anchorToText is true, we don't pass the event so it defaults to text selection anchoring\n    this.colorPickerSvc.toggle(this.editor(), this.mode(), this.anchorToText() ? undefined : event);\n  }\n\n  onClear(event: MouseEvent) {\n    event.preventDefault();\n    event.stopPropagation();\n\n    const editor = this.editor();\n    if (this.mode() === \"text\") {\n      this.colorPickerSvc.unsetColor(editor);\n    } else {\n      this.colorPickerSvc.unsetHighlight(editor);\n    }\n\n    this.colorPickerSvc.close();\n  }\n}\n"]}

package/esm2022/lib/components/edit-toggle/ate-edit-toggle.component.mjs

@@ -0,0 +1,42 @@
+import { Component, input, output, ChangeDetectionStrategy } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { AteButtonComponent } from "../ui/ate-button.component";
+import * as i0 from "@angular/core";
+/**
+ * Edit Toggle Component
+ * Allows switching between editable and readonly modes
+ */
+export class AteEditToggleComponent {
+    constructor() {
+        this.editable = input.required();
+        this.translations = input.required();
+        this.editToggle = output();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteEditToggleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.14", type: AteEditToggleComponent, isStandalone: true, selector: "ate-edit-toggle", inputs: { editable: { classPropertyName: "editable", publicName: "editable", isSignal: true, isRequired: true, transformFunction: null }, translations: { classPropertyName: "translations", publicName: "translations", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { editToggle: "editToggle" }, ngImport: i0, template: `
+    <div class="ate-edit-toggle-container" [class.is-editable]="editable()">
+      <ate-button
+        [icon]="editable() ? 'visibility' : 'edit'"
+        [title]="editable() ? translations().editor.viewMode : translations().editor.toggleEdit"
+        (buttonClick)="editToggle.emit($event)"
+        size="medium"
+        iconSize="small"
+        backgroundColor="var(--ate-primary-lighter)" />
+    </div>
+  `, isInline: true, styles: [".ate-edit-toggle-container{position:absolute;margin-top:16px;right:16px;z-index:50}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: AteButtonComponent, selector: "ate-button", inputs: ["icon", "title", "active", "disabled", "color", "backgroundColor", "variant", "size", "iconSize"], outputs: ["buttonClick"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteEditToggleComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "ate-edit-toggle", standalone: true, imports: [CommonModule, AteButtonComponent], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div class="ate-edit-toggle-container" [class.is-editable]="editable()">
+      <ate-button
+        [icon]="editable() ? 'visibility' : 'edit'"
+        [title]="editable() ? translations().editor.viewMode : translations().editor.toggleEdit"
+        (buttonClick)="editToggle.emit($event)"
+        size="medium"
+        iconSize="small"
+        backgroundColor="var(--ate-primary-lighter)" />
+    </div>
+  `, styles: [".ate-edit-toggle-container{position:absolute;margin-top:16px;right:16px;z-index:50}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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