@formulaxjs/tiptap 0.1.0 → 0.2.0

package/dist/index.global.js

@@ -31222,6 +31222,7 @@ var FormulaX = (() => {
   var FORMULAX_NODE_NAME = "formulaX";
   function resolveOptions(options = {}) {
     return {
+      name: options.name ?? FORMULAX_NODE_NAME,
       formulaClassName: options.formulaClassName ?? DEFAULT_FORMULA_CLASS,
       formulaAttributeName: options.formulaAttributeName ?? DEFAULT_FORMULA_ATTRIBUTE,
       cursorStyle: options.cursorStyle ?? "pointer",
@@ -31243,140 +31244,151 @@ var FormulaX = (() => {
       }
     };
   }
-  var formulaXNodeConfig = {
-    name: FORMULAX_NODE_NAME,
-    group: "inline",
-    inline: true,
-    atom: true,
-    selectable: true,
-    addOptions() {
-      return resolveOptions();
-    },
-    onCreate() {
-      if (typeof document !== "undefined") {
-        ensureFormulaXModalStyles(document);
-      }
-    },
-    addAttributes() {
-      return {
-        latex: {
-          default: ""
+  function warnDuplicateNodeName(extension) {
+    const extensions = extension.editor?.extensionManager?.extensions ?? [];
+    const duplicates = extensions.filter((item) => item?.name === extension.name);
+    if (duplicates.length > 1) {
+      console.warn(
+        `[FormulaX] TipTap node name "${extension.name}" is already registered. Pass a unique "name" option to avoid schema collisions.`
+      );
+    }
+  }
+  function createFormulaXNodeConfig(options) {
+    return {
+      name: options.name,
+      group: "inline",
+      inline: true,
+      atom: true,
+      selectable: true,
+      addOptions() {
+        return options;
+      },
+      onCreate() {
+        warnDuplicateNodeName(this);
+        if (typeof document !== "undefined") {
+          ensureFormulaXModalStyles(document);
         }
-      };
-    },
-    parseHTML() {
-      return [{
-        tag: "span[data-formulax]",
-        getAttrs: (element) => {
-          if (!(element instanceof HTMLElement)) {
-            return false;
+      },
+      addAttributes() {
+        return {
+          latex: {
+            default: ""
           }
-          return {
-            latex: getFormulaLatexFromElement(element, this.options.formulaAttributeName)
-          };
-        }
-      }];
-    },
-    renderHTML({ node }) {
-      if (typeof document === "undefined") {
-        return [
-          "span",
-          {
-            "data-formulax": "true",
-            [this.options.formulaAttributeName]: node.attrs.latex,
-            "data-latex": node.attrs.latex
-          },
-          node.attrs.latex || "\\square"
-        ];
-      }
-      return createFormulaDomElement(document, node.attrs, this.options);
-    },
-    addCommands() {
-      return {
-        openFormulaX: () => () => {
-          const selectedFormula = getSelectedFormula(this.editor);
-          const initialLatex = selectedFormula?.attrs.latex ?? this.options.initialLatex;
-          void openFormulaXTiptapModal({
-            initialLatex,
-            isUpdate: Boolean(selectedFormula),
-            options: this.options
-          }).then((payload) => {
-            if (!payload) {
-              return;
+        };
+      },
+      parseHTML() {
+        return [{
+          tag: "span[data-formulax]",
+          getAttrs: (element) => {
+            if (!(element instanceof HTMLElement)) {
+              return false;
             }
-            applyFormulaPayload(this.editor, payload, selectedFormula);
-            this.editor.commands.focus();
-          });
-          return true;
-        }
-      };
-    },
-    addKeyboardShortcuts() {
-      return {
-        Enter: () => {
-          if (!getSelectedFormula(this.editor)) {
-            return false;
-          }
-          return this.editor.commands.openFormulaX();
-        },
-        Space: () => {
-          if (!getSelectedFormula(this.editor)) {
-            return false;
+            return {
+              latex: getFormulaLatexFromElement(element, this.options.formulaAttributeName)
+            };
           }
-          return this.editor.commands.openFormulaX();
+        }];
+      },
+      renderHTML({ node }) {
+        if (typeof document === "undefined") {
+          return [
+            "span",
+            {
+              "data-formulax": "true",
+              [this.options.formulaAttributeName]: node.attrs.latex,
+              "data-latex": node.attrs.latex
+            },
+            node.attrs.latex || "\\square"
+          ];
         }
-      };
-    },
-    addNodeView() {
-      return ({ editor, getPos, node }) => {
-        const dom = createFormulaDomElement(document, node.attrs, this.options) ?? document.createElement("span");
-        dom.classList.add("formulax-math--interactive");
-        void renderFormulaIntoElement(dom, node.attrs, this.options);
-        const selectNode = () => {
-          const position = getPos();
-          if (typeof position !== "number") {
-            return;
+        return createFormulaDomElement(document, node.attrs, this.options);
+      },
+      addCommands() {
+        return {
+          openFormulaX: () => () => {
+            const selectedFormula = getSelectedFormula(this.editor, this.name);
+            const initialLatex = selectedFormula?.attrs.latex ?? this.options.initialLatex;
+            void openFormulaXTiptapModal({
+              initialLatex,
+              isUpdate: Boolean(selectedFormula),
+              options: this.options
+            }).then((payload) => {
+              if (!payload) {
+                return;
+              }
+              applyFormulaPayload(this.editor, payload, selectedFormula, this.name);
+              this.editor.commands.focus();
+            });
+            return true;
           }
-          editor.commands.setNodeSelection?.(position);
         };
-        dom.addEventListener("click", (event2) => {
-          event2.preventDefault();
-          selectNode();
-        });
-        dom.addEventListener("dblclick", (event2) => {
-          event2.preventDefault();
-          event2.stopPropagation();
-          selectNode();
-          editor.commands.openFormulaX();
-        });
+      },
+      addKeyboardShortcuts() {
         return {
-          dom,
-          update: (updatedNode) => {
-            if (updatedNode.type.name !== FORMULAX_NODE_NAME) {
+          Enter: () => {
+            if (!getSelectedFormula(this.editor, this.name)) {
               return false;
             }
-            syncFormulaDomElement(dom, updatedNode.attrs, this.options);
-            void renderFormulaIntoElement(dom, updatedNode.attrs, this.options);
-            return true;
-          },
-          selectNode: () => {
-            dom.classList.add("ProseMirror-selectednode");
+            return this.editor.commands.openFormulaX();
           },
-          deselectNode: () => {
-            dom.classList.remove("ProseMirror-selectednode");
+          Space: () => {
+            if (!getSelectedFormula(this.editor, this.name)) {
+              return false;
+            }
+            return this.editor.commands.openFormulaX();
           }
         };
-      };
-    }
-  };
+      },
+      addNodeView() {
+        return ({ editor, getPos, node }) => {
+          const dom = createFormulaDomElement(document, node.attrs, this.options) ?? document.createElement("span");
+          dom.classList.add("formulax-math--interactive");
+          void renderFormulaIntoElement(dom, node.attrs, this.options);
+          const selectNode = () => {
+            const position = getPos();
+            if (typeof position !== "number") {
+              return;
+            }
+            editor.commands.setNodeSelection?.(position);
+          };
+          dom.addEventListener("click", (event2) => {
+            event2.preventDefault();
+            selectNode();
+          });
+          dom.addEventListener("dblclick", (event2) => {
+            event2.preventDefault();
+            event2.stopPropagation();
+            selectNode();
+            editor.commands.openFormulaX();
+          });
+          return {
+            dom,
+            update: (updatedNode) => {
+              if (updatedNode.type.name !== this.name) {
+                return false;
+              }
+              syncFormulaDomElement(dom, updatedNode.attrs, this.options);
+              void renderFormulaIntoElement(dom, updatedNode.attrs, this.options);
+              return true;
+            },
+            selectNode: () => {
+              dom.classList.add("ProseMirror-selectednode");
+            },
+            deselectNode: () => {
+              dom.classList.remove("ProseMirror-selectednode");
+            }
+          };
+        };
+      }
+    };
+  }
   function createFormulaXNode(nodeFactory = Node2, options) {
-    const extension = nodeFactory.create(formulaXNodeConfig);
-    return options ? extension.configure(options) : extension;
+    return nodeFactory.create(createFormulaXNodeConfig(resolveOptions(options)));
   }
   var FormulaXNode = createFormulaXNode();
   var createFormulaXPayload = (latex) => parseLatex(latex);
   var serializeFormulaXPayload = (doc2) => serializeLatex(doc2);
-  function applyFormulaPayload(editor, payload, selectedFormula) {
+  function applyFormulaPayload(editor, payload, selectedFormula, nodeName) {
     const latex = payload.latex.trim();
     if (selectedFormula) {
       if (!latex) {
@@ -31391,19 +31403,19 @@ var FormulaX = (() => {
           from: selectedFormula.from,
           to: selectedFormula.to
         },
-        createFormulaNodeContent(payload)
+        createFormulaNodeContent(payload, nodeName)
       ).run();
       return;
     }
     if (!latex) {
       return;
     }
-    editor.chain().focus().insertContent(createFormulaNodeContent(payload)).run();
+    editor.chain().focus().insertContent(createFormulaNodeContent(payload, nodeName)).run();
   }
-  function getSelectedFormula(editor) {
+  function getSelectedFormula(editor, nodeName) {
     const { selection } = editor.state;
     const node = selection.node;
-    if (node?.type?.name !== FORMULAX_NODE_NAME) {
+    if (node?.type?.name !== nodeName) {
       return null;
     }
     return {
@@ -31414,9 +31426,9 @@ var FormulaX = (() => {
       }
     };
   }
-  function createFormulaNodeContent(payload) {
+  function createFormulaNodeContent(payload, nodeName = FORMULAX_NODE_NAME) {
     return {
-      type: FORMULAX_NODE_NAME,
+      type: nodeName,
       attrs: {
         latex: payload.latex
       }