@flogeez/angular-tiptap-editor 2.4.0 → 2.4.1

package/esm2022/lib/extensions/ate-resizable-image.extension.mjs

@@ -0,0 +1,270 @@
+import { Node, mergeAttributes, nodeInputRule } from "@tiptap/core";
+export const AteResizableImage = Node.create({
+    name: "resizableImage",
+    addOptions() {
+        return {
+            inline: false,
+            allowBase64: false,
+            HTMLAttributes: {},
+        };
+    },
+    inline() {
+        return this.options.inline;
+    },
+    group() {
+        return this.options.inline ? "inline" : "block";
+    },
+    draggable: true,
+    addAttributes() {
+        return {
+            src: {
+                default: null,
+            },
+            alt: {
+                default: null,
+            },
+            title: {
+                default: null,
+            },
+            width: {
+                default: null,
+                parseHTML: element => {
+                    const width = element.getAttribute("width");
+                    return width ? parseInt(width, 10) : null;
+                },
+                renderHTML: attributes => {
+                    if (!attributes["width"]) {
+                        return {};
+                    }
+                    return {
+                        width: attributes["width"],
+                    };
+                },
+            },
+            height: {
+                default: null,
+                parseHTML: element => {
+                    const height = element.getAttribute("height");
+                    return height ? parseInt(height, 10) : null;
+                },
+                renderHTML: attributes => {
+                    if (!attributes["height"]) {
+                        return {};
+                    }
+                    return {
+                        height: attributes["height"],
+                    };
+                },
+            },
+        };
+    },
+    parseHTML() {
+        return [
+            {
+                tag: "img[src]",
+            },
+        ];
+    },
+    renderHTML({ HTMLAttributes }) {
+        return ["img", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
+    },
+    addCommands() {
+        return {
+            setResizableImage: options => ({ commands }) => {
+                return commands.insertContent({
+                    type: this.name,
+                    attrs: options,
+                }, {
+                    updateSelection: true,
+                });
+            },
+            updateResizableImage: options => ({ commands }) => {
+                return commands.updateAttributes(this.name, options);
+            },
+        };
+    },
+    addInputRules() {
+        return [
+            nodeInputRule({
+                find: /!\[(.+|:?)]\((\S+)(?:(?:\s+)["'](\S+)["'])?\)/,
+                type: this.type,
+                getAttributes: match => {
+                    const [, alt, src, title] = match;
+                    return { src, alt, title };
+                },
+            }),
+        ];
+    },
+    addNodeView() {
+        return ({ node, getPos, editor }) => {
+            const container = document.createElement("div");
+            container.className = "resizable-image-container";
+            container.style.position = "relative";
+            container.style.display = "inline-block";
+            const img = document.createElement("img");
+            img.src = node.attrs["src"];
+            img.alt = node.attrs["alt"] || "";
+            img.title = node.attrs["title"] || "";
+            img.className = "ate-image";
+            if (node.attrs["width"]) {
+                img.width = node.attrs["width"];
+            }
+            if (node.attrs["height"]) {
+                img.height = node.attrs["height"];
+            }
+            img.parentNode?.insertBefore(container, img);
+            container.appendChild(img);
+            // Add modern resize controls
+            const resizeControls = document.createElement("div");
+            resizeControls.className = "resize-controls";
+            resizeControls.style.display = "none";
+            // Create 8 handles for full resizing capability
+            const handles = ["nw", "n", "ne", "w", "e", "sw", "s", "se"];
+            handles.forEach(direction => {
+                const handle = document.createElement("div");
+                handle.className = `resize-handle resize-handle-${direction}`;
+                handle.setAttribute("data-direction", direction);
+                resizeControls.appendChild(handle);
+            });
+            // Attach controls to container
+            container.appendChild(resizeControls);
+            // Variables for resizing
+            let isResizing = false;
+            let startX = 0;
+            let startY = 0;
+            let startWidth = 0;
+            let startHeight = 0;
+            let aspectRatio = 1;
+            // Calculate aspect ratio
+            img.onload = () => {
+                aspectRatio = img.naturalWidth / img.naturalHeight;
+            };
+            // Resizing logic
+            const handleMouseDown = (e, direction) => {
+                e.preventDefault();
+                e.stopPropagation();
+                isResizing = true;
+                startX = e.clientX;
+                startY = e.clientY;
+                // Use current image dimensions instead of initial ones
+                startWidth =
+                    parseInt(img.getAttribute("width") || "0") || node.attrs["width"] || img.naturalWidth;
+                startHeight =
+                    parseInt(img.getAttribute("height") || "0") || node.attrs["height"] || img.naturalHeight;
+                // Add resizing class to body
+                document.body.classList.add("resizing");
+                const handleMouseMove = (e) => {
+                    if (!isResizing) {
+                        return;
+                    }
+                    const deltaX = e.clientX - startX;
+                    const deltaY = e.clientY - startY;
+                    let newWidth = startWidth;
+                    let newHeight = startHeight;
+                    // Resize according to direction
+                    switch (direction) {
+                        case "e":
+                            newWidth = startWidth + deltaX;
+                            newHeight = newWidth / aspectRatio;
+                            break;
+                        case "w":
+                            newWidth = startWidth - deltaX;
+                            newHeight = newWidth / aspectRatio;
+                            break;
+                        case "s":
+                            newHeight = startHeight + deltaY;
+                            newWidth = newHeight * aspectRatio;
+                            break;
+                        case "n":
+                            newHeight = startHeight - deltaY;
+                            newWidth = newHeight * aspectRatio;
+                            break;
+                        case "se":
+                            newWidth = startWidth + deltaX;
+                            newHeight = startHeight + deltaY;
+                            break;
+                        case "sw":
+                            newWidth = startWidth - deltaX;
+                            newHeight = startHeight + deltaY;
+                            break;
+                        case "ne":
+                            newWidth = startWidth + deltaX;
+                            newHeight = startHeight - deltaY;
+                            break;
+                        case "nw":
+                            newWidth = startWidth - deltaX;
+                            newHeight = startHeight - deltaY;
+                            break;
+                    }
+                    // Limits
+                    newWidth = Math.max(50, Math.min(2000, newWidth));
+                    newHeight = Math.max(50, Math.min(2000, newHeight));
+                    // Update image attributes directly
+                    img.setAttribute("width", Math.round(newWidth).toString());
+                    img.setAttribute("height", Math.round(newHeight).toString());
+                };
+                const handleMouseUp = () => {
+                    isResizing = false;
+                    document.body.classList.remove("resizing");
+                    // Update Tiptap node with new dimensions
+                    if (typeof getPos === "function") {
+                        const finalWidth = parseInt(img.getAttribute("width") || "0");
+                        const finalHeight = parseInt(img.getAttribute("height") || "0");
+                        if (finalWidth && finalHeight) {
+                            editor.commands.updateAttributes("resizableImage", {
+                                width: finalWidth,
+                                height: finalHeight,
+                            });
+                        }
+                    }
+                    document.removeEventListener("mousemove", handleMouseMove);
+                    document.removeEventListener("mouseup", handleMouseUp);
+                };
+                document.addEventListener("mousemove", handleMouseMove);
+                document.addEventListener("mouseup", handleMouseUp);
+            };
+            // Add events to handles
+            resizeControls.addEventListener("mousedown", e => {
+                const target = e.target;
+                if (target.classList.contains("resize-handle")) {
+                    const direction = target.getAttribute("data-direction");
+                    if (direction) {
+                        handleMouseDown(e, direction);
+                    }
+                }
+            });
+            // Proper selection management via ProseMirror lifecycle
+            const selectNode = () => {
+                resizeControls.style.display = "block";
+                container.classList.add("selected");
+                img.classList.add("selected");
+            };
+            const deselectNode = () => {
+                resizeControls.style.display = "none";
+                container.classList.remove("selected");
+                img.classList.remove("selected");
+            };
+            return {
+                dom: container,
+                selectNode,
+                deselectNode,
+                update: updatedNode => {
+                    if (updatedNode.type.name !== "resizableImage") {
+                        return false;
+                    }
+                    img.src = updatedNode.attrs["src"];
+                    img.alt = updatedNode.attrs["alt"] || "";
+                    img.title = updatedNode.attrs["title"] || "";
+                    if (updatedNode.attrs["width"]) {
+                        img.width = updatedNode.attrs["width"];
+                    }
+                    if (updatedNode.attrs["height"]) {
+                        img.height = updatedNode.attrs["height"];
+                    }
+                    return true;
+                },
+            };
+        };
+    },
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ate-resizable-image.extension.js","sourceRoot":"","sources":["../../../../../projects/angular-tiptap-editor/src/lib/extensions/ate-resizable-image.extension.ts"],"names":[],"mappings":"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","sourcesContent":["import { Node, mergeAttributes, nodeInputRule } from \"@tiptap/core\";\n\nexport interface AteResizableImageOptions {\n  inline: boolean;\n  allowBase64: boolean;\n  HTMLAttributes: Record<string, unknown>;\n}\n\ndeclare module \"@tiptap/core\" {\n  interface Commands<ReturnType> {\n    resizableImage: {\n      setResizableImage: (options: {\n        src: string;\n        alt?: string;\n        title?: string;\n        width?: number;\n        height?: number;\n      }) => ReturnType;\n      updateResizableImage: (options: {\n        src?: string;\n        alt?: string;\n        title?: string;\n        width?: number;\n        height?: number;\n      }) => ReturnType;\n    };\n  }\n}\n\nexport const AteResizableImage = Node.create<AteResizableImageOptions>({\n  name: \"resizableImage\",\n\n  addOptions() {\n    return {\n      inline: false,\n      allowBase64: false,\n      HTMLAttributes: {},\n    };\n  },\n\n  inline() {\n    return this.options.inline;\n  },\n\n  group() {\n    return this.options.inline ? \"inline\" : \"block\";\n  },\n\n  draggable: true,\n\n  addAttributes() {\n    return {\n      src: {\n        default: null,\n      },\n      alt: {\n        default: null,\n      },\n      title: {\n        default: null,\n      },\n      width: {\n        default: null,\n        parseHTML: element => {\n          const width = element.getAttribute(\"width\");\n          return width ? parseInt(width, 10) : null;\n        },\n        renderHTML: attributes => {\n          if (!attributes[\"width\"]) {\n            return {};\n          }\n          return {\n            width: attributes[\"width\"],\n          };\n        },\n      },\n      height: {\n        default: null,\n        parseHTML: element => {\n          const height = element.getAttribute(\"height\");\n          return height ? parseInt(height, 10) : null;\n        },\n        renderHTML: attributes => {\n          if (!attributes[\"height\"]) {\n            return {};\n          }\n          return {\n            height: attributes[\"height\"],\n          };\n        },\n      },\n    };\n  },\n\n  parseHTML() {\n    return [\n      {\n        tag: \"img[src]\",\n      },\n    ];\n  },\n\n  renderHTML({ HTMLAttributes }) {\n    return [\"img\", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];\n  },\n\n  addCommands() {\n    return {\n      setResizableImage:\n        options =>\n        ({ commands }) => {\n          return commands.insertContent(\n            {\n              type: this.name,\n              attrs: options,\n            },\n            {\n              updateSelection: true,\n            }\n          );\n        },\n      updateResizableImage:\n        options =>\n        ({ commands }) => {\n          return commands.updateAttributes(this.name, options);\n        },\n    };\n  },\n\n  addInputRules() {\n    return [\n      nodeInputRule({\n        find: /!\\[(.+|:?)]\\((\\S+)(?:(?:\\s+)[\"'](\\S+)[\"'])?\\)/,\n        type: this.type,\n        getAttributes: match => {\n          const [, alt, src, title] = match;\n          return { src, alt, title };\n        },\n      }),\n    ];\n  },\n\n  addNodeView() {\n    return ({ node, getPos, editor }) => {\n      const container = document.createElement(\"div\");\n      container.className = \"resizable-image-container\";\n      container.style.position = \"relative\";\n      container.style.display = \"inline-block\";\n\n      const img = document.createElement(\"img\");\n      img.src = node.attrs[\"src\"];\n      img.alt = node.attrs[\"alt\"] || \"\";\n      img.title = node.attrs[\"title\"] || \"\";\n      img.className = \"ate-image\";\n\n      if (node.attrs[\"width\"]) {\n        img.width = node.attrs[\"width\"];\n      }\n      if (node.attrs[\"height\"]) {\n        img.height = node.attrs[\"height\"];\n      }\n\n      img.parentNode?.insertBefore(container, img);\n      container.appendChild(img);\n\n      // Add modern resize controls\n      const resizeControls = document.createElement(\"div\");\n      resizeControls.className = \"resize-controls\";\n      resizeControls.style.display = \"none\";\n\n      // Create 8 handles for full resizing capability\n      const handles = [\"nw\", \"n\", \"ne\", \"w\", \"e\", \"sw\", \"s\", \"se\"];\n      handles.forEach(direction => {\n        const handle = document.createElement(\"div\");\n        handle.className = `resize-handle resize-handle-${direction}`;\n        handle.setAttribute(\"data-direction\", direction);\n        resizeControls.appendChild(handle);\n      });\n\n      // Attach controls to container\n      container.appendChild(resizeControls);\n\n      // Variables for resizing\n      let isResizing = false;\n      let startX = 0;\n      let startY = 0;\n      let startWidth = 0;\n      let startHeight = 0;\n      let aspectRatio = 1;\n\n      // Calculate aspect ratio\n      img.onload = () => {\n        aspectRatio = img.naturalWidth / img.naturalHeight;\n      };\n\n      // Resizing logic\n      const handleMouseDown = (e: MouseEvent, direction: string) => {\n        e.preventDefault();\n        e.stopPropagation();\n\n        isResizing = true;\n        startX = e.clientX;\n        startY = e.clientY;\n\n        // Use current image dimensions instead of initial ones\n        startWidth =\n          parseInt(img.getAttribute(\"width\") || \"0\") || node.attrs[\"width\"] || img.naturalWidth;\n        startHeight =\n          parseInt(img.getAttribute(\"height\") || \"0\") || node.attrs[\"height\"] || img.naturalHeight;\n\n        // Add resizing class to body\n        document.body.classList.add(\"resizing\");\n\n        const handleMouseMove = (e: MouseEvent) => {\n          if (!isResizing) {\n            return;\n          }\n\n          const deltaX = e.clientX - startX;\n          const deltaY = e.clientY - startY;\n\n          let newWidth = startWidth;\n          let newHeight = startHeight;\n\n          // Resize according to direction\n          switch (direction) {\n            case \"e\":\n              newWidth = startWidth + deltaX;\n              newHeight = newWidth / aspectRatio;\n              break;\n            case \"w\":\n              newWidth = startWidth - deltaX;\n              newHeight = newWidth / aspectRatio;\n              break;\n            case \"s\":\n              newHeight = startHeight + deltaY;\n              newWidth = newHeight * aspectRatio;\n              break;\n            case \"n\":\n              newHeight = startHeight - deltaY;\n              newWidth = newHeight * aspectRatio;\n              break;\n            case \"se\":\n              newWidth = startWidth + deltaX;\n              newHeight = startHeight + deltaY;\n              break;\n            case \"sw\":\n              newWidth = startWidth - deltaX;\n              newHeight = startHeight + deltaY;\n              break;\n            case \"ne\":\n              newWidth = startWidth + deltaX;\n              newHeight = startHeight - deltaY;\n              break;\n            case \"nw\":\n              newWidth = startWidth - deltaX;\n              newHeight = startHeight - deltaY;\n              break;\n          }\n\n          // Limits\n          newWidth = Math.max(50, Math.min(2000, newWidth));\n          newHeight = Math.max(50, Math.min(2000, newHeight));\n\n          // Update image attributes directly\n          img.setAttribute(\"width\", Math.round(newWidth).toString());\n          img.setAttribute(\"height\", Math.round(newHeight).toString());\n        };\n\n        const handleMouseUp = () => {\n          isResizing = false;\n          document.body.classList.remove(\"resizing\");\n\n          // Update Tiptap node with new dimensions\n          if (typeof getPos === \"function\") {\n            const finalWidth = parseInt(img.getAttribute(\"width\") || \"0\");\n            const finalHeight = parseInt(img.getAttribute(\"height\") || \"0\");\n\n            if (finalWidth && finalHeight) {\n              editor.commands.updateAttributes(\"resizableImage\", {\n                width: finalWidth,\n                height: finalHeight,\n              });\n            }\n          }\n\n          document.removeEventListener(\"mousemove\", handleMouseMove);\n          document.removeEventListener(\"mouseup\", handleMouseUp);\n        };\n\n        document.addEventListener(\"mousemove\", handleMouseMove);\n        document.addEventListener(\"mouseup\", handleMouseUp);\n      };\n\n      // Add events to handles\n      resizeControls.addEventListener(\"mousedown\", e => {\n        const target = e.target as HTMLElement;\n        if (target.classList.contains(\"resize-handle\")) {\n          const direction = target.getAttribute(\"data-direction\");\n          if (direction) {\n            handleMouseDown(e, direction);\n          }\n        }\n      });\n\n      // Proper selection management via ProseMirror lifecycle\n      const selectNode = () => {\n        resizeControls.style.display = \"block\";\n        container.classList.add(\"selected\");\n        img.classList.add(\"selected\");\n      };\n\n      const deselectNode = () => {\n        resizeControls.style.display = \"none\";\n        container.classList.remove(\"selected\");\n        img.classList.remove(\"selected\");\n      };\n\n      return {\n        dom: container,\n        selectNode,\n        deselectNode,\n        update: updatedNode => {\n          if (updatedNode.type.name !== \"resizableImage\") {\n            return false;\n          }\n\n          img.src = updatedNode.attrs[\"src\"];\n          img.alt = updatedNode.attrs[\"alt\"] || \"\";\n          img.title = updatedNode.attrs[\"title\"] || \"\";\n\n          if (updatedNode.attrs[\"width\"]) {\n            img.width = updatedNode.attrs[\"width\"];\n          }\n          if (updatedNode.attrs[\"height\"]) {\n            img.height = updatedNode.attrs[\"height\"];\n          }\n\n          return true;\n        },\n      };\n    };\n  },\n});\n"]}

package/esm2022/lib/extensions/ate-table.extension.mjs

@@ -0,0 +1,29 @@
+import { Extension } from "@tiptap/core";
+import { Table } from "@tiptap/extension-table";
+import { TableRow } from "@tiptap/extension-table-row";
+import { TableCell } from "@tiptap/extension-table-cell";
+import { TableHeader } from "@tiptap/extension-table-header";
+export const AteTableExtension = Extension.create({
+    name: "tableExtension",
+    addExtensions() {
+        return [
+            Table.configure({
+                resizable: true,
+                handleWidth: 5,
+                cellMinWidth: 100,
+            }),
+            TableRow,
+            TableHeader.configure({
+                HTMLAttributes: {
+                    class: "table-header",
+                },
+            }),
+            TableCell.configure({
+                HTMLAttributes: {
+                    class: "table-cell",
+                },
+            }),
+        ];
+    },
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXRlLXRhYmxlLmV4dGVuc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItdGlwdGFwLWVkaXRvci9zcmMvbGliL2V4dGVuc2lvbnMvYXRlLXRhYmxlLmV4dGVuc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNoRCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDdkQsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQ3pELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUU3RCxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRyxTQUFTLENBQUMsTUFBTSxDQUFDO0lBQ2hELElBQUksRUFBRSxnQkFBZ0I7SUFFdEIsYUFBYTtRQUNYLE9BQU87WUFDTCxLQUFLLENBQUMsU0FBUyxDQUFDO2dCQUNkLFNBQVMsRUFBRSxJQUFJO2dCQUNmLFdBQVcsRUFBRSxDQUFDO2dCQUNkLFlBQVksRUFBRSxHQUFHO2FBQ2xCLENBQUM7WUFDRixRQUFRO1lBQ1IsV0FBVyxDQUFDLFNBQVMsQ0FBQztnQkFDcEIsY0FBYyxFQUFFO29CQUNkLEtBQUssRUFBRSxjQUFjO2lCQUN0QjthQUNGLENBQUM7WUFDRixTQUFTLENBQUMsU0FBUyxDQUFDO2dCQUNsQixjQUFjLEVBQUU7b0JBQ2QsS0FBSyxFQUFFLFlBQVk7aUJBQ3BCO2FBQ0YsQ0FBQztTQUNILENBQUM7SUFDSixDQUFDO0NBQ0YsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXh0ZW5zaW9uIH0gZnJvbSBcIkB0aXB0YXAvY29yZVwiO1xuaW1wb3J0IHsgVGFibGUgfSBmcm9tIFwiQHRpcHRhcC9leHRlbnNpb24tdGFibGVcIjtcbmltcG9ydCB7IFRhYmxlUm93IH0gZnJvbSBcIkB0aXB0YXAvZXh0ZW5zaW9uLXRhYmxlLXJvd1wiO1xuaW1wb3J0IHsgVGFibGVDZWxsIH0gZnJvbSBcIkB0aXB0YXAvZXh0ZW5zaW9uLXRhYmxlLWNlbGxcIjtcbmltcG9ydCB7IFRhYmxlSGVhZGVyIH0gZnJvbSBcIkB0aXB0YXAvZXh0ZW5zaW9uLXRhYmxlLWhlYWRlclwiO1xuXG5leHBvcnQgY29uc3QgQXRlVGFibGVFeHRlbnNpb24gPSBFeHRlbnNpb24uY3JlYXRlKHtcbiAgbmFtZTogXCJ0YWJsZUV4dGVuc2lvblwiLFxuXG4gIGFkZEV4dGVuc2lvbnMoKSB7XG4gICAgcmV0dXJuIFtcbiAgICAgIFRhYmxlLmNvbmZpZ3VyZSh7XG4gICAgICAgIHJlc2l6YWJsZTogdHJ1ZSxcbiAgICAgICAgaGFuZGxlV2lkdGg6IDUsXG4gICAgICAgIGNlbGxNaW5XaWR0aDogMTAwLFxuICAgICAgfSksXG4gICAgICBUYWJsZVJvdyxcbiAgICAgIFRhYmxlSGVhZGVyLmNvbmZpZ3VyZSh7XG4gICAgICAgIEhUTUxBdHRyaWJ1dGVzOiB7XG4gICAgICAgICAgY2xhc3M6IFwidGFibGUtaGVhZGVyXCIsXG4gICAgICAgIH0sXG4gICAgICB9KSxcbiAgICAgIFRhYmxlQ2VsbC5jb25maWd1cmUoe1xuICAgICAgICBIVE1MQXR0cmlidXRlczoge1xuICAgICAgICAgIGNsYXNzOiBcInRhYmxlLWNlbGxcIixcbiAgICAgICAgfSxcbiAgICAgIH0pLFxuICAgIF07XG4gIH0sXG59KTtcbiJdfQ==

package/esm2022/lib/extensions/ate-tiptap-state.extension.mjs

@@ -0,0 +1,85 @@
+import { Extension } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { ATE_INITIAL_EDITOR_STATE, } from "../models/ate-editor-state.model";
+/**
+ * High-performance flat property merger.
+ * Processes sub-objects (marks, can, nodes) property by property.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function fastMerge(target, source) {
+    if (!source) {
+        return;
+    }
+    for (const key in source) {
+        const sourceVal = source[key];
+        // If the value is an object (marks, can, nodes, selection)
+        if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal)) {
+            if (!target[key]) {
+                target[key] = {};
+            }
+            // Merge internal properties
+            for (const subKey in sourceVal) {
+                const subVal = sourceVal[subKey];
+                // TRUE priority rule for boolean state categories
+                if (typeof subVal === "boolean" && (key === "marks" || key === "can" || key === "nodes")) {
+                    target[key][subKey] = target[key][subKey] || subVal;
+                }
+                else {
+                    target[key][subKey] = subVal;
+                }
+            }
+        }
+        else {
+            // Simple value (isFocused, isEditable)
+            target[key] = sourceVal;
+        }
+    }
+}
+function createFreshSnapshot() {
+    return JSON.parse(JSON.stringify(ATE_INITIAL_EDITOR_STATE));
+}
+export const AteTiptapStateExtension = Extension.create({
+    name: "ateTiptapState",
+    addOptions() {
+        return {
+            onUpdate: undefined,
+            calculators: [],
+        };
+    },
+    addProseMirrorPlugins() {
+        return [
+            new Plugin({
+                key: new PluginKey("tiptapState"),
+                view: () => ({
+                    update: _view => {
+                        const { editor } = this;
+                        if (!editor) {
+                            return;
+                        }
+                        const snapshot = createFreshSnapshot();
+                        const calcs = this.options.calculators;
+                        for (const calculator of calcs) {
+                            try {
+                                const partial = calculator(editor);
+                                fastMerge(snapshot, partial);
+                            }
+                            catch (e) {
+                                console.error("TiptapStateExtension: Calculator error", e);
+                            }
+                        }
+                        if (this.options.onUpdate) {
+                            this.options.onUpdate(snapshot);
+                        }
+                    },
+                }),
+            }),
+        ];
+    },
+    onFocus() {
+        this.editor.view.dispatch(this.editor.state.tr.setMeta("tiptapStateForceUpdate", true));
+    },
+    onBlur() {
+        this.editor.view.dispatch(this.editor.state.tr.setMeta("tiptapStateForceUpdate", true));
+    },
+});
+//# sourceMappingURL=data:application/json;base64,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