@flogeez/angular-tiptap-editor 3.1.2 → 3.1.4

package/esm2022/lib/extensions/ate-upload-progress.extension.mjs

@@ -0,0 +1,195 @@
+import { Extension } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+export const AteUploadProgress = Extension.create({
+    name: "uploadProgress",
+    addOptions() {
+        return {
+            isUploading: () => false,
+            uploadProgress: () => 0,
+            uploadMessage: () => "",
+        };
+    },
+    addProseMirrorPlugins() {
+        const options = this.options;
+        return [
+            new Plugin({
+                key: new PluginKey("uploadProgress"),
+                state: {
+                    init() {
+                        return {
+                            decorations: DecorationSet.empty,
+                            isUploading: false,
+                            uploadPosition: null,
+                        };
+                    },
+                    apply: (tr, state) => {
+                        const isUploading = options.isUploading();
+                        // Si l'upload commence, sauvegarder la position
+                        if (isUploading && !state.isUploading) {
+                            const uploadPosition = tr.selection.from;
+                            const uploadProgress = options.uploadProgress();
+                            const uploadMessage = options.uploadMessage();
+                            // Créer un élément de progression
+                            const uploadElement = document.createElement("div");
+                            uploadElement.className = "upload-progress-widget";
+                            uploadElement.innerHTML = `
+                <div class="upload-skeleton">
+                  <div class="upload-content">
+                    <div class="upload-icon">
+                      <span class="material-symbols-outlined spinning">image</span>
+                    </div>
+                    <div class="upload-info">
+                      <div class="upload-message">${uploadMessage}</div>
+                      <div class="progress-bar">
+                        <div class="progress-fill" style="width: ${uploadProgress}%"></div>
+                      </div>
+                      <div class="progress-text">${uploadProgress}%</div>
+                    </div>
+                  </div>
+                </div>
+              `;
+                            // Ajouter les styles si pas déjà fait
+                            if (!document.querySelector("#upload-progress-styles")) {
+                                const style = document.createElement("style");
+                                style.id = "upload-progress-styles";
+                                style.textContent = `
+                  .upload-progress-widget {
+                    display: block;
+                    margin: 8px 0;
+                    max-width: 400px;
+                  }
+                  .upload-skeleton {
+                    background: var(--ate-surface-secondary);
+                    border: 2px dashed var(--ate-border-color);
+                    border-radius: var(--ate-border-radius);
+                    padding: 16px;
+                    display: flex;
+                    align-items: center;
+                    justify-content: center;
+                    min-height: 120px;
+                    animation: pulse 2s infinite;
+                  }
+                  @keyframes pulse {
+                    0%, 100% { background-color: var(--ate-surface-secondary); }
+                    50% { background-color: var(--ate-surface-tertiary); }
+                  }
+                  .upload-content {
+                    display: flex;
+                    flex-direction: column;
+                    align-items: center;
+                    gap: 12px;
+                    text-align: center;
+                  }
+                  .upload-icon {
+                    display: flex;
+                    align-items: center;
+                    justify-content: center;
+                    width: 48px;
+                    height: 48px;
+                    background: var(--ate-primary-light);
+                    border-radius: 50%;
+                    color: var(--ate-primary);
+                  }
+                  .upload-icon .material-symbols-outlined {
+                    font-size: 24px;
+                  }
+                  .spinning {
+                    animation: spin 1s linear infinite;
+                  }
+                  @keyframes spin {
+                    from { transform: rotate(0deg); }
+                    to { transform: rotate(360deg); }
+                  }
+                  .upload-info {
+                    display: flex;
+                    flex-direction: column;
+                    gap: 8px;
+                    width: 100%;
+                    max-width: 200px;
+                  }
+                  .upload-message {
+                    font-size: 14px;
+                    color: var(--ate-text);
+                    font-weight: 500;
+                  }
+                  .progress-bar {
+                    width: 100%;
+                    height: 6px;
+                    background: var(--ate-border-color);
+                    border-radius: 3px;
+                    overflow: hidden;
+                  }
+                  .progress-fill {
+                    height: 100%;
+                    background: var(--ate-primary);
+                    border-radius: 3px;
+                    transition: width 0.3s ease;
+                  }
+                  .progress-text {
+                    font-size: 12px;
+                    color: var(--ate-text-secondary);
+                    font-weight: 500;
+                  }
+                `;
+                                document.head.appendChild(style);
+                            }
+                            // Créer une décoration widget à la position sauvegardée
+                            const decoration = Decoration.widget(uploadPosition, uploadElement, {
+                                side: 1,
+                                key: "upload-progress",
+                            });
+                            return {
+                                decorations: DecorationSet.create(tr.doc, [decoration]),
+                                isUploading: true,
+                                uploadPosition,
+                            };
+                        }
+                        // Si l'upload continue, mettre à jour le contenu
+                        if (isUploading && state.isUploading && state.uploadPosition !== null) {
+                            const uploadProgress = options.uploadProgress();
+                            const uploadMessage = options.uploadMessage();
+                            // Mettre à jour le contenu de l'élément existant
+                            const existingElement = document.querySelector(".upload-progress-widget");
+                            if (existingElement) {
+                                existingElement.innerHTML = `
+                  <div class="upload-skeleton">
+                    <div class="upload-content">
+                      <div class="upload-icon">
+                        <span class="material-symbols-outlined spinning">image</span>
+                      </div>
+                      <div class="upload-info">
+                        <div class="upload-message">${uploadMessage}</div>
+                        <div class="progress-bar">
+                          <div class="progress-fill" style="width: ${uploadProgress}%"></div>
+                        </div>
+                        <div class="progress-text">${uploadProgress}%</div>
+                      </div>
+                    </div>
+                  </div>
+                `;
+                            }
+                            return state; // Garder les décorations existantes
+                        }
+                        // Si l'upload se termine, supprimer les décorations
+                        if (!isUploading && state.isUploading) {
+                            return {
+                                decorations: DecorationSet.empty,
+                                isUploading: false,
+                                uploadPosition: null,
+                            };
+                        }
+                        return state;
+                    },
+                },
+                props: {
+                    decorations(state) {
+                        const pluginState = this.getState(state);
+                        return pluginState ? pluginState.decorations : DecorationSet.empty;
+                    },
+                },
+            }),
+        ];
+    },
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ate-upload-progress.extension.js","sourceRoot":"","sources":["../../../../../projects/angular-tiptap-editor/src/lib/extensions/ate-upload-progress.extension.ts"],"names":[],"mappings":"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","sourcesContent":["import { Extension } from \"@tiptap/core\";\nimport { Plugin, PluginKey } from \"@tiptap/pm/state\";\nimport { Decoration, DecorationSet } from \"@tiptap/pm/view\";\n\nexport interface AteUploadProgressOptions {\n  isUploading: () => boolean;\n  uploadProgress: () => number;\n  uploadMessage: () => string;\n}\n\nexport const AteUploadProgress = Extension.create<AteUploadProgressOptions>({\n  name: \"uploadProgress\",\n\n  addOptions() {\n    return {\n      isUploading: () => false,\n      uploadProgress: () => 0,\n      uploadMessage: () => \"\",\n    };\n  },\n\n  addProseMirrorPlugins() {\n    const options = this.options;\n\n    return [\n      new Plugin({\n        key: new PluginKey(\"uploadProgress\"),\n        state: {\n          init() {\n            return {\n              decorations: DecorationSet.empty,\n              isUploading: false,\n              uploadPosition: null as number | null,\n            };\n          },\n          apply: (tr, state) => {\n            const isUploading = options.isUploading();\n\n            // Si l'upload commence, sauvegarder la position\n            if (isUploading && !state.isUploading) {\n              const uploadPosition = tr.selection.from;\n              const uploadProgress = options.uploadProgress();\n              const uploadMessage = options.uploadMessage();\n\n              // Créer un élément de progression\n              const uploadElement = document.createElement(\"div\");\n              uploadElement.className = \"upload-progress-widget\";\n              uploadElement.innerHTML = `\n                <div class=\"upload-skeleton\">\n                  <div class=\"upload-content\">\n                    <div class=\"upload-icon\">\n                      <span class=\"material-symbols-outlined spinning\">image</span>\n                    </div>\n                    <div class=\"upload-info\">\n                      <div class=\"upload-message\">${uploadMessage}</div>\n                      <div class=\"progress-bar\">\n                        <div class=\"progress-fill\" style=\"width: ${uploadProgress}%\"></div>\n                      </div>\n                      <div class=\"progress-text\">${uploadProgress}%</div>\n                    </div>\n                  </div>\n                </div>\n              `;\n\n              // Ajouter les styles si pas déjà fait\n              if (!document.querySelector(\"#upload-progress-styles\")) {\n                const style = document.createElement(\"style\");\n                style.id = \"upload-progress-styles\";\n                style.textContent = `\n                  .upload-progress-widget {\n                    display: block;\n                    margin: 8px 0;\n                    max-width: 400px;\n                  }\n                  .upload-skeleton {\n                    background: var(--ate-surface-secondary);\n                    border: 2px dashed var(--ate-border-color);\n                    border-radius: var(--ate-border-radius);\n                    padding: 16px;\n                    display: flex;\n                    align-items: center;\n                    justify-content: center;\n                    min-height: 120px;\n                    animation: pulse 2s infinite;\n                  }\n                  @keyframes pulse {\n                    0%, 100% { background-color: var(--ate-surface-secondary); }\n                    50% { background-color: var(--ate-surface-tertiary); }\n                  }\n                  .upload-content {\n                    display: flex;\n                    flex-direction: column;\n                    align-items: center;\n                    gap: 12px;\n                    text-align: center;\n                  }\n                  .upload-icon {\n                    display: flex;\n                    align-items: center;\n                    justify-content: center;\n                    width: 48px;\n                    height: 48px;\n                    background: var(--ate-primary-light);\n                    border-radius: 50%;\n                    color: var(--ate-primary);\n                  }\n                  .upload-icon .material-symbols-outlined {\n                    font-size: 24px;\n                  }\n                  .spinning {\n                    animation: spin 1s linear infinite;\n                  }\n                  @keyframes spin {\n                    from { transform: rotate(0deg); }\n                    to { transform: rotate(360deg); }\n                  }\n                  .upload-info {\n                    display: flex;\n                    flex-direction: column;\n                    gap: 8px;\n                    width: 100%;\n                    max-width: 200px;\n                  }\n                  .upload-message {\n                    font-size: 14px;\n                    color: var(--ate-text);\n                    font-weight: 500;\n                  }\n                  .progress-bar {\n                    width: 100%;\n                    height: 6px;\n                    background: var(--ate-border-color);\n                    border-radius: 3px;\n                    overflow: hidden;\n                  }\n                  .progress-fill {\n                    height: 100%;\n                    background: var(--ate-primary);\n                    border-radius: 3px;\n                    transition: width 0.3s ease;\n                  }\n                  .progress-text {\n                    font-size: 12px;\n                    color: var(--ate-text-secondary);\n                    font-weight: 500;\n                  }\n                `;\n                document.head.appendChild(style);\n              }\n\n              // Créer une décoration widget à la position sauvegardée\n              const decoration = Decoration.widget(uploadPosition, uploadElement, {\n                side: 1,\n                key: \"upload-progress\",\n              });\n\n              return {\n                decorations: DecorationSet.create(tr.doc, [decoration]),\n                isUploading: true,\n                uploadPosition,\n              };\n            }\n\n            // Si l'upload continue, mettre à jour le contenu\n            if (isUploading && state.isUploading && state.uploadPosition !== null) {\n              const uploadProgress = options.uploadProgress();\n              const uploadMessage = options.uploadMessage();\n\n              // Mettre à jour le contenu de l'élément existant\n              const existingElement = document.querySelector(\".upload-progress-widget\");\n              if (existingElement) {\n                existingElement.innerHTML = `\n                  <div class=\"upload-skeleton\">\n                    <div class=\"upload-content\">\n                      <div class=\"upload-icon\">\n                        <span class=\"material-symbols-outlined spinning\">image</span>\n                      </div>\n                      <div class=\"upload-info\">\n                        <div class=\"upload-message\">${uploadMessage}</div>\n                        <div class=\"progress-bar\">\n                          <div class=\"progress-fill\" style=\"width: ${uploadProgress}%\"></div>\n                        </div>\n                        <div class=\"progress-text\">${uploadProgress}%</div>\n                      </div>\n                    </div>\n                  </div>\n                `;\n              }\n\n              return state; // Garder les décorations existantes\n            }\n\n            // Si l'upload se termine, supprimer les décorations\n            if (!isUploading && state.isUploading) {\n              return {\n                decorations: DecorationSet.empty,\n                isUploading: false,\n                uploadPosition: null,\n              };\n            }\n\n            return state;\n          },\n        },\n        props: {\n          decorations(state) {\n            const pluginState = this.getState(state);\n            return pluginState ? pluginState.decorations : DecorationSet.empty;\n          },\n        },\n      }),\n    ];\n  },\n});\n"]}

package/esm2022/lib/extensions/calculators/ate-discovery.calculator.mjs

@@ -0,0 +1,62 @@
+/**
+ * DiscoveryCalculator automatically detects and tracks the state of any TipTap extension.
+ * It provides a "fallback" reactive state for any mark or node not explicitly handled
+ * by specialized calculators.
+ */
+export const AteDiscoveryCalculator = (editor) => {
+    const state = {
+        marks: {},
+        nodes: {},
+    };
+    // We skip core extensions that are already handled by specialized calculators
+    // to avoid redundant calculations and maintain precise attribute tracking.
+    const handled = [
+        "bold",
+        "italic",
+        "underline",
+        "strike",
+        "code",
+        "link",
+        "highlight",
+        "superscript",
+        "subscript",
+        "table",
+        "image",
+        "resizableImage",
+        "heading",
+        "bulletList",
+        "orderedList",
+        "blockquote",
+        "textAlign",
+        "textStyle",
+        "color",
+    ];
+    editor.extensionManager.extensions.forEach(extension => {
+        const name = extension.name;
+        const type = extension.type;
+        // Skip internal/core extensions or already handled ones
+        if ([
+            "selection",
+            "editable",
+            "focus",
+            "undo",
+            "redo",
+            "history",
+            "placeholder",
+            "characterCount",
+        ].includes(name)) {
+            return;
+        }
+        if (handled.includes(name)) {
+            return;
+        }
+        if (type === "mark") {
+            state.marks[name] = editor.isActive(name);
+        }
+        else if (type === "node") {
+            state.nodes[name] = editor.isActive(name);
+        }
+    });
+    return state;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/extensions/calculators/ate-image.calculator.mjs

@@ -0,0 +1,8 @@
+export const AteImageCalculator = editor => {
+    return {
+        nodes: {
+            isImage: editor.isActive("image") || editor.isActive("resizableImage"),
+        },
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXRlLWltYWdlLmNhbGN1bGF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRpcHRhcC1lZGl0b3Ivc3JjL2xpYi9leHRlbnNpb25zL2NhbGN1bGF0b3JzL2F0ZS1pbWFnZS5jYWxjdWxhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUF1QixNQUFNLENBQUMsRUFBRTtJQUM3RCxPQUFPO1FBQ0wsS0FBSyxFQUFFO1lBQ0wsT0FBTyxFQUFFLE1BQU0sQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLElBQUksTUFBTSxDQUFDLFFBQVEsQ0FBQyxnQkFBZ0IsQ0FBQztTQUN2RTtLQUNGLENBQUM7QUFDSixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBdGVTdGF0ZUNhbGN1bGF0b3IgfSBmcm9tIFwiLi4vLi4vbW9kZWxzL2F0ZS1lZGl0b3Itc3RhdGUubW9kZWxcIjtcblxuZXhwb3J0IGNvbnN0IEF0ZUltYWdlQ2FsY3VsYXRvcjogQXRlU3RhdGVDYWxjdWxhdG9yID0gZWRpdG9yID0+IHtcbiAgcmV0dXJuIHtcbiAgICBub2Rlczoge1xuICAgICAgaXNJbWFnZTogZWRpdG9yLmlzQWN0aXZlKFwiaW1hZ2VcIikgfHwgZWRpdG9yLmlzQWN0aXZlKFwicmVzaXphYmxlSW1hZ2VcIiksXG4gICAgfSxcbiAgfTtcbn07XG4iXX0=

package/esm2022/lib/extensions/calculators/ate-marks.calculator.mjs

@@ -0,0 +1,75 @@
+import { normalizeColor } from "../../utils/ate-color.utils";
+export const AteMarksCalculator = editor => {
+    const isCodeBlock = editor.isActive("codeBlock");
+    const isCode = editor.isActive("code"); // Inline code mark
+    const isImage = editor.isActive("image") || editor.isActive("resizableImage");
+    // Check if marks are generally allowed based on context
+    const marksAllowed = !isCodeBlock && !isImage;
+    // For inline code specifically, we don't allow nesting OTHER marks inside it,
+    // but the code mark ITSELF must be togglable to be removed.
+    const isInsideInlineCode = isCode;
+    // 1. Resolve target element once for this calculation
+    const getTargetElement = () => {
+        if (typeof window === "undefined" || !editor.view?.dom) {
+            return null;
+        }
+        try {
+            const { from } = editor.state.selection;
+            const { node } = editor.view.domAtPos(from);
+            return node.nodeType === Node.TEXT_NODE ? node.parentElement : node;
+        }
+        catch (_e) {
+            return null;
+        }
+    };
+    const targetEl = getTargetElement() || (typeof window !== "undefined" ? editor.view?.dom : null);
+    const computedStyle = targetEl && typeof window !== "undefined" ? window.getComputedStyle(targetEl) : null;
+    // 2. Lightweight helper to extract properties from the pre-calculated style object
+    const getStyle = (prop) => {
+        if (!computedStyle) {
+            return null;
+        }
+        const val = computedStyle.getPropertyValue(prop);
+        return normalizeColor(val);
+    };
+    const colorMark = editor.getAttributes("textStyle")["color"] || null;
+    const backgroundMark = editor.getAttributes("highlight")["color"] || null;
+    return {
+        marks: {
+            bold: editor.isActive("bold"),
+            italic: editor.isActive("italic"),
+            underline: editor.isActive("underline"),
+            strike: editor.isActive("strike"),
+            code: isCode,
+            superscript: editor.isActive("superscript"),
+            subscript: editor.isActive("subscript"),
+            highlight: editor.isActive("highlight"),
+            link: editor.isActive("link"),
+            linkHref: editor.getAttributes("link")["href"] || null,
+            color: colorMark,
+            computedColor: colorMark || getStyle("color"),
+            background: backgroundMark,
+            computedBackground: backgroundMark || getStyle("background-color"),
+            linkOpenOnClick: editor.extensionManager.extensions.find(ext => ext.name === "link")?.options?.openOnClick ??
+                false,
+        },
+        can: {
+            toggleBold: marksAllowed && !isInsideInlineCode && editor.can().toggleBold(),
+            toggleItalic: marksAllowed && !isInsideInlineCode && editor.can().toggleItalic(),
+            toggleUnderline: marksAllowed && !isInsideInlineCode && editor.can().toggleUnderline(),
+            toggleStrike: marksAllowed && !isInsideInlineCode && editor.can().toggleStrike(),
+            toggleCode: marksAllowed && editor.can().toggleCode(),
+            toggleHighlight: marksAllowed && !isInsideInlineCode && editor.can().toggleHighlight(),
+            toggleLink: marksAllowed &&
+                !isInsideInlineCode &&
+                (editor.can().setLink({ href: "" }) || editor.can().unsetLink()),
+            toggleSuperscript: marksAllowed && !isInsideInlineCode && editor.can().toggleSuperscript(),
+            toggleSubscript: marksAllowed && !isInsideInlineCode && editor.can().toggleSubscript(),
+            setColor: marksAllowed && !isInsideInlineCode && editor.can().setColor(""),
+            setHighlight: marksAllowed && !isInsideInlineCode && editor.can().setHighlight(),
+            undo: editor.can().undo(),
+            redo: editor.can().redo(),
+        },
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ate-marks.calculator.js","sourceRoot":"","sources":["../../../../../../projects/angular-tiptap-editor/src/lib/extensions/calculators/ate-marks.calculator.ts"],"names":[],"mappings":"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","sourcesContent":["import { AteStateCalculator } from \"../../models/ate-editor-state.model\";\nimport { normalizeColor } from \"../../utils/ate-color.utils\";\n\nexport const AteMarksCalculator: AteStateCalculator = editor => {\n  const isCodeBlock = editor.isActive(\"codeBlock\");\n  const isCode = editor.isActive(\"code\"); // Inline code mark\n  const isImage = editor.isActive(\"image\") || editor.isActive(\"resizableImage\");\n\n  // Check if marks are generally allowed based on context\n  const marksAllowed = !isCodeBlock && !isImage;\n  // For inline code specifically, we don't allow nesting OTHER marks inside it,\n  // but the code mark ITSELF must be togglable to be removed.\n  const isInsideInlineCode = isCode;\n\n  // 1. Resolve target element once for this calculation\n  const getTargetElement = (): Element | null => {\n    if (typeof window === \"undefined\" || !editor.view?.dom) {\n      return null;\n    }\n    try {\n      const { from } = editor.state.selection;\n      const { node } = editor.view.domAtPos(from);\n      return node.nodeType === Node.TEXT_NODE ? node.parentElement : (node as Element);\n    } catch (_e) {\n      return null;\n    }\n  };\n\n  const targetEl = getTargetElement() || (typeof window !== \"undefined\" ? editor.view?.dom : null);\n  const computedStyle =\n    targetEl && typeof window !== \"undefined\" ? window.getComputedStyle(targetEl) : null;\n\n  // 2. Lightweight helper to extract properties from the pre-calculated style object\n  const getStyle = (prop: string): string | null => {\n    if (!computedStyle) {\n      return null;\n    }\n    const val = computedStyle.getPropertyValue(prop);\n    return normalizeColor(val);\n  };\n\n  const colorMark = editor.getAttributes(\"textStyle\")[\"color\"] || null;\n  const backgroundMark = editor.getAttributes(\"highlight\")[\"color\"] || null;\n\n  return {\n    marks: {\n      bold: editor.isActive(\"bold\"),\n      italic: editor.isActive(\"italic\"),\n      underline: editor.isActive(\"underline\"),\n      strike: editor.isActive(\"strike\"),\n      code: isCode,\n      superscript: editor.isActive(\"superscript\"),\n      subscript: editor.isActive(\"subscript\"),\n      highlight: editor.isActive(\"highlight\"),\n      link: editor.isActive(\"link\"),\n      linkHref: editor.getAttributes(\"link\")[\"href\"] || null,\n      color: colorMark,\n      computedColor: colorMark || getStyle(\"color\"),\n      background: backgroundMark,\n      computedBackground: backgroundMark || getStyle(\"background-color\"),\n      linkOpenOnClick:\n        editor.extensionManager.extensions.find(ext => ext.name === \"link\")?.options?.openOnClick ??\n        false,\n    },\n    can: {\n      toggleBold: marksAllowed && !isInsideInlineCode && editor.can().toggleBold(),\n      toggleItalic: marksAllowed && !isInsideInlineCode && editor.can().toggleItalic(),\n      toggleUnderline: marksAllowed && !isInsideInlineCode && editor.can().toggleUnderline(),\n      toggleStrike: marksAllowed && !isInsideInlineCode && editor.can().toggleStrike(),\n      toggleCode: marksAllowed && editor.can().toggleCode(),\n      toggleHighlight: marksAllowed && !isInsideInlineCode && editor.can().toggleHighlight(),\n      toggleLink:\n        marksAllowed &&\n        !isInsideInlineCode &&\n        (editor.can().setLink({ href: \"\" }) || editor.can().unsetLink()),\n      toggleSuperscript: marksAllowed && !isInsideInlineCode && editor.can().toggleSuperscript(),\n      toggleSubscript: marksAllowed && !isInsideInlineCode && editor.can().toggleSubscript(),\n      setColor: marksAllowed && !isInsideInlineCode && editor.can().setColor(\"\"),\n      setHighlight: marksAllowed && !isInsideInlineCode && editor.can().setHighlight(),\n      undo: editor.can().undo(),\n      redo: editor.can().redo(),\n    },\n  };\n};\n"]}

package/esm2022/lib/extensions/calculators/ate-selection.calculator.mjs

@@ -0,0 +1,35 @@
+import { TextSelection, NodeSelection } from "@tiptap/pm/state";
+import { CellSelection } from "@tiptap/pm/tables";
+export const AteSelectionCalculator = editor => {
+    const { selection } = editor.state;
+    const { from, to } = selection;
+    let selectionType = "none";
+    if (selection instanceof TextSelection) {
+        selectionType = "text";
+    }
+    else if (selection instanceof NodeSelection) {
+        selectionType = "node";
+    }
+    else if (selection instanceof CellSelection) {
+        selectionType = "cell";
+    }
+    let isSingleCell = false;
+    if (selection instanceof CellSelection) {
+        isSingleCell = selection.$anchorCell.pos === selection.$headCell.pos;
+    }
+    return {
+        isFocused: editor.view.hasFocus(),
+        isEditable: editor.isEditable,
+        selection: {
+            type: selectionType,
+            from,
+            to,
+            empty: selection.empty || (selectionType === "text" && from === to),
+            isSingleCell: isSingleCell,
+        },
+        nodes: {
+            activeNodeName: editor.state.doc.nodeAt(editor.state.selection.$head.pos)?.type.name || null,
+        },
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/extensions/calculators/ate-structure.calculator.mjs

@@ -0,0 +1,34 @@
+export const AteStructureCalculator = editor => {
+    return {
+        nodes: {
+            isBlockquote: editor.isActive("blockquote"),
+            isCodeBlock: editor.isActive("codeBlock"),
+            isBulletList: editor.isActive("bulletList"),
+            isOrderedList: editor.isActive("orderedList"),
+            h1: editor.isActive("heading", { level: 1 }),
+            h2: editor.isActive("heading", { level: 2 }),
+            h3: editor.isActive("heading", { level: 3 }),
+            alignLeft: editor.isActive({ textAlign: "left" }),
+            alignCenter: editor.isActive({ textAlign: "center" }),
+            alignRight: editor.isActive({ textAlign: "right" }),
+            alignJustify: editor.isActive({ textAlign: "justify" }),
+        },
+        can: {
+            toggleHeading1: editor.can().toggleHeading({ level: 1 }),
+            toggleHeading2: editor.can().toggleHeading({ level: 2 }),
+            toggleHeading3: editor.can().toggleHeading({ level: 3 }),
+            toggleBulletList: editor.can().toggleBulletList(),
+            toggleOrderedList: editor.can().toggleOrderedList(),
+            toggleBlockquote: editor.can().toggleBlockquote(),
+            toggleCodeBlock: editor.can().toggleCodeBlock(),
+            setTextAlignLeft: editor.can().setTextAlign("left"),
+            setTextAlignCenter: editor.can().setTextAlign("center"),
+            setTextAlignRight: editor.can().setTextAlign("right"),
+            setTextAlignJustify: editor.can().setTextAlign("justify"),
+            insertHorizontalRule: editor.can().setHorizontalRule(),
+            insertTable: editor.can().insertTable(),
+            insertImage: editor.can().setResizableImage({ src: "" }),
+        },
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/extensions/calculators/ate-table.calculator.mjs

@@ -0,0 +1,38 @@
+import { NodeSelection } from "@tiptap/pm/state";
+export const AteTableCalculator = editor => {
+    const isTable = editor.isActive("table");
+    if (!isTable) {
+        return {
+            nodes: {
+                isTable: false,
+                isTableCell: false,
+                isTableHeaderRow: false,
+                isTableHeaderColumn: false,
+            },
+        };
+    }
+    const { selection } = editor.state;
+    return {
+        nodes: {
+            isTable: true,
+            isTableNodeSelected: selection instanceof NodeSelection && selection.node.type.name === "table",
+            isTableCell: editor.isActive("tableCell") || editor.isActive("tableHeader"),
+            isTableHeaderRow: editor.isActive("tableHeader", { row: true }),
+            isTableHeaderColumn: editor.isActive("tableHeader", { column: true }),
+        },
+        can: {
+            addRowBefore: editor.can().addRowBefore(),
+            addRowAfter: editor.can().addRowAfter(),
+            deleteRow: editor.can().deleteRow(),
+            addColumnBefore: editor.can().addColumnBefore(),
+            addColumnAfter: editor.can().addColumnAfter(),
+            deleteColumn: editor.can().deleteColumn(),
+            deleteTable: editor.can().deleteTable(),
+            mergeCells: editor.can().mergeCells(),
+            splitCell: editor.can().splitCell(),
+            toggleHeaderRow: editor.can().toggleHeaderRow(),
+            toggleHeaderColumn: editor.can().toggleHeaderColumn(),
+        },
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/models/ate-bubble-menu.model.mjs

@@ -0,0 +1,53 @@
+/**
+ * Clés des options du menu bulle de texte
+ */
+export const ATE_BUBBLE_MENU_KEYS = [
+    "bold",
+    "italic",
+    "underline",
+    "strike",
+    "code",
+    "superscript",
+    "subscript",
+    "highlight",
+    "highlightPicker",
+    "textColor",
+    "link",
+    "separator",
+];
+/**
+ * Clés des options du menu bulle d'image
+ */
+export const ATE_IMAGE_BUBBLE_MENU_KEYS = [
+    "changeImage",
+    "downloadImage",
+    "resizeSmall",
+    "resizeMedium",
+    "resizeLarge",
+    "resizeOriginal",
+    "alignLeft",
+    "alignCenter",
+    "alignRight",
+    "deleteImage",
+    "separator",
+];
+/**
+ * Clés des options du menu de table
+ */
+export const ATE_TABLE_BUBBLE_MENU_KEYS = [
+    "addRowBefore",
+    "addRowAfter",
+    "deleteRow",
+    "addColumnBefore",
+    "addColumnAfter",
+    "deleteColumn",
+    "deleteTable",
+    "toggleHeaderRow",
+    "toggleHeaderColumn",
+    "separator",
+];
+/**
+ * Clés des options du menu de cellule
+ */
+export const ATE_CELL_BUBBLE_MENU_KEYS = ["mergeCells", "splitCell"];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/models/ate-editor-config.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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