@pie-lib/editable-html-tip-tap 1.0.0

package/lib/extensions/math.js

@@ -0,0 +1,330 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ZeroWidthSpaceHandlingPlugin = exports.MathNodeView = exports.MathNode = exports.EnsureTextAfterMathPlugin = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _core = require("@tiptap/core");
+
+var _react2 = require("@tiptap/react");
+
+var _prosemirrorState = require("prosemirror-state");
+
+var _mathToolbar = require("@pie-lib/math-toolbar");
+
+var _mathRendering = require("@pie-lib/math-rendering");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+var ensureTextAfterMathPluginKey = new _prosemirrorState.PluginKey('ensureTextAfterMath');
+
+var EnsureTextAfterMathPlugin = function EnsureTextAfterMathPlugin(mathNodeName) {
+  return new _prosemirrorState.Plugin({
+    key: ensureTextAfterMathPluginKey,
+    appendTransaction: function appendTransaction(transactions, oldState, newState) {
+      // Only act when the doc actually changed
+      if (!transactions.some(function (tr) {
+        return tr.docChanged;
+      })) return null;
+      var tr = newState.tr;
+      var changed = false;
+      newState.doc.descendants(function (node, pos) {
+        if (node.type.name === mathNodeName) {
+          var nextPos = pos + node.nodeSize;
+          var nextNode = newState.doc.nodeAt(nextPos); // If there's no node after, or the next node isn't text, insert a space
+
+          if (!nextNode || nextNode.type.name !== 'text') {
+            tr.insert(nextPos, newState.schema.text("\u200B"));
+            changed = true;
+          }
+        }
+      });
+      return changed ? tr : null;
+    }
+  });
+};
+
+exports.EnsureTextAfterMathPlugin = EnsureTextAfterMathPlugin;
+var ZeroWidthSpaceHandlingPlugin = new _prosemirrorState.Plugin({
+  key: new _prosemirrorState.PluginKey('zeroWidthSpaceHandling'),
+  props: {
+    handleKeyDown: function handleKeyDown(view, event) {
+      var state = view.state,
+          dispatch = view.dispatch;
+      var selection = state.selection,
+          doc = state.doc;
+      var from = selection.from,
+          empty = selection.empty;
+
+      if (empty && event.key === 'Backspace' && from > 0) {
+        var prevChar = doc.textBetween(from - 1, from, "\uFFFC", "\uFFFC");
+
+        if (prevChar === "\u200B") {
+          var tr = state.tr["delete"](from - 2, from);
+          dispatch(tr);
+          return true; // handled
+        }
+      }
+
+      if (empty && event.key === 'ArrowLeft' && from > 0) {
+        var _prevChar = doc.textBetween(from - 1, from, "\uFFFC", "\uFFFC"); // If the previous character is the zero-width space...
+
+
+        if (_prevChar === "\u200B") {
+          var posBefore = from - 1;
+          var resolved = state.doc.resolve(posBefore - 1); // look just before the zwsp
+
+          var maybeNode = resolved.nodeAfter || resolved.nodeBefore; // Check if there's an inline selectable node (e.g., your math node)
+
+          if (maybeNode) {
+            var nodePos = posBefore - maybeNode.nodeSize;
+            var nodeResolved = state.doc.resolve(nodePos);
+
+            var _tr = state.tr.setSelection(_prosemirrorState.NodeSelection.create(state.doc, nodeResolved.pos));
+
+            dispatch(_tr);
+            return true;
+          } else {
+            // Just move the text cursor before the zwsp
+            var _tr2 = state.tr.setSelection(_prosemirrorState.TextSelection.create(state.doc, from - 2));
+
+            dispatch(_tr2);
+            return true;
+          }
+        }
+      }
+
+      return false;
+    }
+  }
+});
+exports.ZeroWidthSpaceHandlingPlugin = ZeroWidthSpaceHandlingPlugin;
+
+var MathNode = _core.Node.create({
+  name: 'math',
+  group: 'inline',
+  inline: true,
+  atom: true,
+  addAttributes: function addAttributes() {
+    return {
+      latex: {
+        "default": ''
+      },
+      wrapper: {
+        "default": null
+      },
+      html: {
+        "default": null
+      }
+    };
+  },
+  addProseMirrorPlugins: function addProseMirrorPlugins() {
+    return [EnsureTextAfterMathPlugin(this.name), ZeroWidthSpaceHandlingPlugin];
+  },
+  parseHTML: function parseHTML() {
+    return [{
+      tag: 'span[data-latex]',
+      getAttrs: function getAttrs(el) {
+        return {
+          latex: el.getAttribute('data-raw') || el.textContent
+        };
+      }
+    }, {
+      tag: 'span[data-type="mathml"]',
+      getAttrs: function getAttrs(el) {
+        return {
+          html: el.innerHTML
+        };
+      }
+    }];
+  },
+  addCommands: function addCommands() {
+    var _this = this;
+
+    return {
+      insertMath: function insertMath() {
+        var latex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+        return function (_ref) {
+          var _node$type;
+
+          var tr = _ref.tr,
+              editor = _ref.editor,
+              dispatch = _ref.dispatch;
+          // 2) Now the editor.view.state reflects the insertion
+          var state = editor.view.state;
+          var node = state.schema.nodes.math.create({
+            latex: latex
+          });
+          var selection = state.selection; // The inserted node is typically just before the cursor
+
+          var pos = selection.$from.pos;
+          tr.insert(pos, node);
+
+          if ((node === null || node === void 0 ? void 0 : (_node$type = node.type) === null || _node$type === void 0 ? void 0 : _node$type.name) === _this.name) {
+            // Create a NodeSelection from the current doc
+            var sel = _prosemirrorState.NodeSelection.create(tr.doc, selection.$from.pos); // Build a fresh transaction from the current state and set the selection
+
+
+            tr.setSelection(sel);
+          }
+
+          dispatch(tr);
+          return true;
+        };
+      } // insertMath: (latex = '') => ({ commands }) => {
+      //   return commands.insertContent({
+      //     type: this.name,
+      //     attrs: { latex },
+      //   });
+      // },
+
+    };
+  },
+  renderHTML: function renderHTML(_ref2) {
+    var HTMLAttributes = _ref2.HTMLAttributes;
+
+    if (HTMLAttributes.html) {
+      return ['span', {
+        'data-type': 'mathml',
+        dangerouslySetInnerHTML: {
+          __html: HTMLAttributes.html
+        }
+      }];
+    }
+
+    return ['span', {
+      'data-latex': '',
+      'data-raw': HTMLAttributes.latex
+    }, (0, _mathRendering.wrapMath)(HTMLAttributes.latex, HTMLAttributes.wrapper)];
+  },
+  addNodeView: function addNodeView() {
+    var _this2 = this;
+
+    return (0, _react2.ReactNodeViewRenderer)(function (props) {
+      return /*#__PURE__*/_react["default"].createElement(MathNodeView, _objectSpread(_objectSpread({}, props), {}, {
+        options: _this2.options
+      }));
+    });
+  }
+});
+
+exports.MathNode = MathNode;
+
+var MathNodeView = function MathNodeView(props) {
+  var node = props.node,
+      updateAttributes = props.updateAttributes,
+      editor = props.editor,
+      selected = props.selected,
+      options = props.options;
+
+  var _useState = (0, _react.useState)(selected),
+      _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+      showToolbar = _useState2[0],
+      setShowToolbar = _useState2[1];
+
+  var toolbarRef = (0, _react.useRef)(null);
+  var latex = node.attrs.latex || '';
+  (0, _react.useEffect)(function () {
+    if (selected) {
+      setShowToolbar(true);
+    }
+  }, [selected]);
+  (0, _react.useEffect)(function () {
+    editor._toolbarOpened = !!showToolbar;
+  }, [showToolbar]);
+  (0, _react.useEffect)(function () {
+    var handleClickOutside = function handleClickOutside(event) {
+      if (toolbarRef.current && !toolbarRef.current.contains(event.target) && !event.target.closest('[data-inline-node]')) {
+        setShowToolbar(false);
+      }
+    };
+
+    if (showToolbar) {
+      document.addEventListener('mousedown', handleClickOutside);
+    } else {
+      document.removeEventListener('mousedown', handleClickOutside);
+    }
+
+    return function () {
+      return document.removeEventListener('mousedown', handleClickOutside);
+    };
+  }, [showToolbar]);
+
+  var handleChange = function handleChange(newLatex) {
+    updateAttributes({
+      latex: newLatex
+    });
+  };
+
+  var handleDone = function handleDone(newLatex) {
+    updateAttributes({
+      latex: newLatex
+    });
+    setShowToolbar(false);
+    editor._toolbarOpened = false;
+    var _editor$state = editor.state,
+        selection = _editor$state.selection,
+        tr = _editor$state.tr,
+        doc = _editor$state.doc;
+
+    var sel = _prosemirrorState.TextSelection.create(doc, selection.from + 1); // Build a fresh transaction from the current state and set the selection
+
+
+    tr.setSelection(sel);
+    editor.view.dispatch(tr);
+    editor.commands.focus();
+  };
+
+  return /*#__PURE__*/_react["default"].createElement(_react2.NodeViewWrapper, {
+    className: "math-node",
+    style: {
+      display: 'inline-flex',
+      cursor: 'pointer',
+      margin: '0 4px'
+    },
+    "data-selected": selected
+  }, /*#__PURE__*/_react["default"].createElement("div", {
+    onClick: function onClick() {
+      return setShowToolbar(true);
+    },
+    contentEditable: false
+  }, /*#__PURE__*/_react["default"].createElement(_mathToolbar.MathPreview, {
+    latex: latex
+  })), showToolbar && /*#__PURE__*/_react["default"].createElement("div", {
+    ref: toolbarRef,
+    style: {
+      position: 'absolute',
+      top: '100%',
+      left: 0,
+      zIndex: 20,
+      background: 'var(--editable-html-toolbar-bg, #efefef)',
+      boxShadow: '0px 1px 5px 0px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 3px 1px -2px rgba(0, 0, 0, 0.12)'
+    }
+  }, /*#__PURE__*/_react["default"].createElement(_mathToolbar.MathToolbar, {
+    latex: latex,
+    autoFocus: true,
+    onChange: handleChange,
+    onDone: handleDone,
+    keypadMode: "basic"
+  })));
+};
+
+exports.MathNodeView = MathNodeView;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/extensions/math.js"],"names":["ensureTextAfterMathPluginKey","PluginKey","EnsureTextAfterMathPlugin","mathNodeName","Plugin","key","appendTransaction","transactions","oldState","newState","some","tr","docChanged","changed","doc","descendants","node","pos","type","name","nextPos","nodeSize","nextNode","nodeAt","insert","schema","text","ZeroWidthSpaceHandlingPlugin","props","handleKeyDown","view","event","state","dispatch","selection","from","empty","prevChar","textBetween","posBefore","resolved","resolve","maybeNode","nodeAfter","nodeBefore","nodePos","nodeResolved","setSelection","NodeSelection","create","TextSelection","MathNode","Node","group","inline","atom","addAttributes","latex","wrapper","html","addProseMirrorPlugins","parseHTML","tag","getAttrs","el","getAttribute","textContent","innerHTML","addCommands","insertMath","editor","nodes","math","$from","sel","renderHTML","HTMLAttributes","dangerouslySetInnerHTML","__html","addNodeView","options","MathNodeView","updateAttributes","selected","showToolbar","setShowToolbar","toolbarRef","attrs","_toolbarOpened","handleClickOutside","current","contains","target","closest","document","addEventListener","removeEventListener","handleChange","newLatex","handleDone","commands","focus","display","cursor","margin","position","top","left","zIndex","background","boxShadow"],"mappings":"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","sourcesContent":["import React, { useState, useEffect, useRef } from 'react';\nimport { Extension, Node, mergeAttributes } from '@tiptap/core';\nimport { NodeViewWrapper, ReactRenderer, ReactNodeViewRenderer } from '@tiptap/react';\nimport { Plugin, PluginKey, NodeSelection, TextSelection } from 'prosemirror-state';\nimport { MathPreview, MathToolbar } from '@pie-lib/math-toolbar';\nimport { wrapMath, mmlToLatex, renderMath } from '@pie-lib/math-rendering';\n\nconst ensureTextAfterMathPluginKey = new PluginKey('ensureTextAfterMath');\n\nexport const EnsureTextAfterMathPlugin = (mathNodeName) =>\n  new Plugin({\n    key: ensureTextAfterMathPluginKey,\n    appendTransaction: (transactions, oldState, newState) => {\n      // Only act when the doc actually changed\n      if (!transactions.some((tr) => tr.docChanged)) return null;\n\n      const tr = newState.tr;\n      let changed = false;\n\n      newState.doc.descendants((node, pos) => {\n        if (node.type.name === mathNodeName) {\n          const nextPos = pos + node.nodeSize;\n          const nextNode = newState.doc.nodeAt(nextPos);\n\n          // If there's no node after, or the next node isn't text, insert a space\n          if (!nextNode || nextNode.type.name !== 'text') {\n            tr.insert(nextPos, newState.schema.text('\\u200b'));\n            changed = true;\n          }\n        }\n      });\n\n      return changed ? tr : null;\n    },\n  });\n\nexport const ZeroWidthSpaceHandlingPlugin = new Plugin({\n  key: new PluginKey('zeroWidthSpaceHandling'),\n  props: {\n    handleKeyDown(view, event) {\n      const { state, dispatch } = view;\n      const { selection, doc } = state;\n      const { from, empty } = selection;\n\n      if (empty && event.key === 'Backspace' && from > 0) {\n        const prevChar = doc.textBetween(from - 1, from, '\\uFFFC', '\\uFFFC');\n        if (prevChar === '\\u200b') {\n          const tr = state.tr.delete(from - 2, from);\n          dispatch(tr);\n          return true; // handled\n        }\n      }\n\n      if (empty && event.key === 'ArrowLeft' && from > 0) {\n        const prevChar = doc.textBetween(from - 1, from, '\\uFFFC', '\\uFFFC');\n        // If the previous character is the zero-width space...\n        if (prevChar === '\\u200b') {\n          const posBefore = from - 1;\n          const resolved = state.doc.resolve(posBefore - 1); // look just before the zwsp\n          const maybeNode = resolved.nodeAfter || resolved.nodeBefore;\n\n          // Check if there's an inline selectable node (e.g., your math node)\n          if (maybeNode) {\n            const nodePos = posBefore - maybeNode.nodeSize;\n            const nodeResolved = state.doc.resolve(nodePos);\n            const tr = state.tr.setSelection(NodeSelection.create(state.doc, nodeResolved.pos));\n            dispatch(tr);\n            return true;\n          } else {\n            // Just move the text cursor before the zwsp\n            const tr = state.tr.setSelection(TextSelection.create(state.doc, from - 2));\n            dispatch(tr);\n            return true;\n          }\n        }\n      }\n\n      return false;\n    },\n  },\n});\n\nexport const MathNode = Node.create({\n  name: 'math',\n  group: 'inline',\n  inline: true,\n  atom: true,\n\n  addAttributes() {\n    return {\n      latex: { default: '' },\n      wrapper: { default: null },\n      html: { default: null },\n    };\n  },\n\n  addProseMirrorPlugins() {\n    return [EnsureTextAfterMathPlugin(this.name), ZeroWidthSpaceHandlingPlugin];\n  },\n\n  parseHTML() {\n    return [\n      {\n        tag: 'span[data-latex]',\n        getAttrs: (el) => ({\n          latex: el.getAttribute('data-raw') || el.textContent,\n        }),\n      },\n      {\n        tag: 'span[data-type=\"mathml\"]',\n        getAttrs: (el) => ({\n          html: el.innerHTML,\n        }),\n      },\n    ];\n  },\n\n  addCommands() {\n    return {\n      insertMath: (latex = '') => ({ tr, editor, dispatch }) => {\n        // 2) Now the editor.view.state reflects the insertion\n        const { state } = editor.view;\n        const node = state.schema.nodes.math.create({\n          latex,\n        });\n        const { selection } = state;\n\n        // The inserted node is typically just before the cursor\n        const pos = selection.$from.pos;\n\n        tr.insert(pos, node);\n\n        if (node?.type?.name === this.name) {\n          // Create a NodeSelection from the current doc\n          const sel = NodeSelection.create(tr.doc, selection.$from.pos);\n\n          // Build a fresh transaction from the current state and set the selection\n          tr.setSelection(sel);\n        }\n\n        dispatch(tr);\n\n        return true;\n      },\n      // insertMath: (latex = '') => ({ commands }) => {\n      //   return commands.insertContent({\n      //     type: this.name,\n      //     attrs: { latex },\n      //   });\n      // },\n    };\n  },\n\n  renderHTML({ HTMLAttributes }) {\n    if (HTMLAttributes.html) {\n      return ['span', { 'data-type': 'mathml', dangerouslySetInnerHTML: { __html: HTMLAttributes.html } }];\n    }\n\n    return [\n      'span',\n      { 'data-latex': '', 'data-raw': HTMLAttributes.latex },\n      wrapMath(HTMLAttributes.latex, HTMLAttributes.wrapper),\n    ];\n  },\n\n  addNodeView() {\n    return ReactNodeViewRenderer((props) => <MathNodeView {...{ ...props, options: this.options }} />);\n  },\n});\n\nexport const MathNodeView = (props) => {\n  const { node, updateAttributes, editor, selected, options } = props;\n  const [showToolbar, setShowToolbar] = useState(selected);\n  const toolbarRef = useRef(null);\n\n  const latex = node.attrs.latex || '';\n\n  useEffect(() => {\n    if (selected) {\n      setShowToolbar(true);\n    }\n  }, [selected]);\n\n  useEffect(() => {\n    editor._toolbarOpened = !!showToolbar;\n  }, [showToolbar]);\n\n  useEffect(() => {\n    const handleClickOutside = (event) => {\n      if (\n        toolbarRef.current &&\n        !toolbarRef.current.contains(event.target) &&\n        !event.target.closest('[data-inline-node]')\n      ) {\n        setShowToolbar(false);\n      }\n    };\n\n    if (showToolbar) {\n      document.addEventListener('mousedown', handleClickOutside);\n    } else {\n      document.removeEventListener('mousedown', handleClickOutside);\n    }\n\n    return () => document.removeEventListener('mousedown', handleClickOutside);\n  }, [showToolbar]);\n\n  const handleChange = (newLatex) => {\n    updateAttributes({ latex: newLatex });\n  };\n\n  const handleDone = (newLatex) => {\n    updateAttributes({ latex: newLatex });\n    setShowToolbar(false);\n\n    editor._toolbarOpened = false;\n\n    const { selection, tr, doc } = editor.state;\n    const sel = TextSelection.create(doc, selection.from + 1);\n\n    // Build a fresh transaction from the current state and set the selection\n    tr.setSelection(sel);\n    editor.view.dispatch(tr);\n    editor.commands.focus();\n  };\n\n  return (\n    <NodeViewWrapper\n      className=\"math-node\"\n      style={{\n        display: 'inline-flex',\n        cursor: 'pointer',\n        margin: '0 4px',\n      }}\n      data-selected={selected}\n    >\n      <div onClick={() => setShowToolbar(true)} contentEditable={false}>\n        <MathPreview latex={latex} />\n      </div>\n\n      {showToolbar && (\n        <div\n          ref={toolbarRef}\n          style={{\n            position: 'absolute',\n            top: '100%',\n            left: 0,\n            zIndex: 20,\n            background: 'var(--editable-html-toolbar-bg, #efefef)',\n            boxShadow:\n              '0px 1px 5px 0px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 3px 1px -2px rgba(0, 0, 0, 0.12)',\n          }}\n        >\n          <MathToolbar latex={latex} autoFocus onChange={handleChange} onDone={handleDone} keypadMode=\"basic\" />\n        </div>\n      )}\n    </NodeViewWrapper>\n  );\n};\n"]}

package/lib/extensions/media.js

@@ -0,0 +1,276 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Media = void 0;
+exports["default"] = MediaNodeView;
+exports.insertDialog = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reactDom = _interopRequireDefault(require("react-dom"));
+
+var _core = require("@tiptap/core");
+
+var _react2 = require("@tiptap/react");
+
+var _mediaDialog = _interopRequireDefault(require("../plugins/media/media-dialog"));
+
+var _mediaToolbar = _interopRequireDefault(require("../plugins/media/media-toolbar"));
+
+var _excluded = ["type", "callback", "options"];
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+var Media = _core.Node.create({
+  name: 'media',
+  group: 'inline',
+  inline: true,
+  atom: true,
+  addAttributes: function addAttributes() {
+    return {
+      type: {
+        "default": 'video'
+      },
+      src: {
+        "default": null
+      },
+      width: {
+        "default": null
+      },
+      height: {
+        "default": null
+      },
+      title: {
+        "default": null
+      },
+      starts: {
+        "default": null
+      },
+      ends: {
+        "default": null
+      },
+      editing: {
+        "default": false
+      },
+      tag: {
+        "default": 'iframe'
+      },
+      // 'iframe' or 'audio'
+      url: {
+        "default": null
+      }
+    };
+  },
+  parseHTML: function parseHTML() {
+    return [{
+      tag: 'iframe[data-type="video"]',
+      getAttrs: function getAttrs(el) {
+        return {
+          type: 'video',
+          tag: 'iframe',
+          src: el.getAttribute('src'),
+          width: el.getAttribute('width'),
+          height: el.getAttribute('height'),
+          title: el.dataset.title,
+          starts: el.dataset.starts,
+          ends: el.dataset.ends,
+          url: el.dataset.url
+        };
+      }
+    }, {
+      tag: 'audio',
+      getAttrs: function getAttrs(el) {
+        var _el$querySelector;
+
+        return {
+          type: 'audio',
+          tag: 'audio',
+          src: (_el$querySelector = el.querySelector('source')) === null || _el$querySelector === void 0 ? void 0 : _el$querySelector.getAttribute('src')
+        };
+      }
+    }];
+  },
+  renderHTML: function renderHTML(_ref) {
+    var HTMLAttributes = _ref.HTMLAttributes;
+    var tag = HTMLAttributes.tag,
+        src = HTMLAttributes.src,
+        width = HTMLAttributes.width,
+        height = HTMLAttributes.height;
+
+    if (tag === 'audio') {
+      return ['audio', {
+        controls: 'controls',
+        controlsList: 'nodownload'
+      }, ['source', {
+        src: src,
+        type: 'audio/mp3'
+      }]];
+    }
+
+    return ['iframe', (0, _core.mergeAttributes)({
+      'data-type': 'video',
+      frameborder: '0',
+      allow: 'accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture',
+      allowfullscreen: '',
+      src: src
+    }, width ? {
+      width: width
+    } : {}, height ? {
+      height: height
+    } : {})];
+  },
+  addCommands: function addCommands() {
+    var _this = this;
+
+    return {
+      insertMedia: function insertMedia(attrs) {
+        return function (_ref2) {
+          var commands = _ref2.commands;
+          return commands.insertContent({
+            type: _this.name,
+            attrs: attrs
+          });
+        };
+      },
+      updateMedia: function updateMedia(attrs) {
+        return function (_ref3) {
+          var commands = _ref3.commands;
+          return commands.updateAttributes(_this.name, attrs);
+        };
+      }
+    };
+  },
+  addNodeView: function addNodeView() {
+    var _this2 = this;
+
+    return (0, _react2.ReactNodeViewRenderer)(function (props) {
+      return /*#__PURE__*/_react["default"].createElement(MediaNodeView, _objectSpread(_objectSpread({}, props), {}, {
+        options: _this2.options
+      }));
+    });
+  }
+});
+
+exports.Media = Media;
+
+var removeDialogs = function removeDialogs() {
+  var prevDialogs = document.querySelectorAll('.insert-media-dialog');
+  prevDialogs.forEach(function (s) {
+    return s.remove();
+  });
+};
+
+var insertDialog = function insertDialog(props) {
+  var newEl = document.createElement('div');
+  var type = props.type,
+      callback = props.callback,
+      options = props.options,
+      rest = (0, _objectWithoutProperties2["default"])(props, _excluded);
+  var initialBodyOverflow = document.body.style.overflow;
+  removeDialogs();
+  newEl.className = 'insert-media-dialog';
+  document.body.style.overflow = 'hidden';
+
+  var handleClose = function handleClose(val, data) {
+    callback(val, data);
+    newEl.remove();
+    document.body.style.overflow = initialBodyOverflow;
+  };
+
+  var el = /*#__PURE__*/_react["default"].createElement(_mediaDialog["default"], (0, _extends2["default"])({}, rest, {
+    uploadSoundSupport: options.uploadSoundSupport,
+    type: type,
+    disablePortal: true,
+    open: true,
+    handleClose: handleClose
+  }));
+
+  _reactDom["default"].render(el, newEl);
+
+  document.body.appendChild(newEl);
+};
+
+exports.insertDialog = insertDialog;
+
+function MediaNodeView(_ref4) {
+  var editor = _ref4.editor,
+      node = _ref4.node,
+      updateAttributes = _ref4.updateAttributes,
+      deleteNode = _ref4.deleteNode,
+      options = _ref4.options;
+  var _node$attrs = node.attrs,
+      type = _node$attrs.type,
+      src = _node$attrs.src,
+      width = _node$attrs.width,
+      height = _node$attrs.height,
+      tag = _node$attrs.tag;
+
+  var handleEdit = function handleEdit() {
+    insertDialog(_objectSpread(_objectSpread({}, node.attrs), {}, {
+      edit: true,
+      callback: function callback(val, data) {
+        if (val) {
+          updateAttributes(data);
+        } else {
+          deleteNode();
+        }
+
+        editor.chain().focus().run();
+      }
+    }));
+  };
+
+  (0, _react.useEffect)(function () {
+    insertDialog(_objectSpread(_objectSpread({}, node.attrs), {}, {
+      options: options,
+      edit: true,
+      callback: function callback(val, data) {
+        if (val) {
+          updateAttributes(data);
+        } else {
+          deleteNode();
+        }
+
+        editor.chain().focus().run();
+      }
+    }));
+  }, []);
+  return /*#__PURE__*/_react["default"].createElement(_react2.NodeViewWrapper, {
+    "data-type": type,
+    style: {
+      width: width,
+      height: height
+    }
+  }, tag === 'audio' ? /*#__PURE__*/_react["default"].createElement("audio", {
+    controls: true,
+    controlsList: "nodownload"
+  }, /*#__PURE__*/_react["default"].createElement("source", {
+    src: src
+  })) : /*#__PURE__*/_react["default"].createElement("iframe", {
+    src: src,
+    allowFullScreen: true,
+    frameBorder: "0"
+  }), /*#__PURE__*/_react["default"].createElement(_mediaToolbar["default"], {
+    onEdit: handleEdit,
+    onRemove: deleteNode
+  }));
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/extensions/media.js"],"names":["Media","Node","create","name","group","inline","atom","addAttributes","type","src","width","height","title","starts","ends","editing","tag","url","parseHTML","getAttrs","el","getAttribute","dataset","querySelector","renderHTML","HTMLAttributes","controls","controlsList","frameborder","allow","allowfullscreen","addCommands","insertMedia","attrs","commands","insertContent","updateMedia","updateAttributes","addNodeView","props","options","removeDialogs","prevDialogs","document","querySelectorAll","forEach","s","remove","insertDialog","newEl","createElement","callback","rest","initialBodyOverflow","body","style","overflow","className","handleClose","val","data","uploadSoundSupport","ReactDOM","render","appendChild","MediaNodeView","editor","node","deleteNode","handleEdit","edit","chain","focus","run"],"mappings":"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","sourcesContent":["import React, { useEffect } from 'react';\nimport ReactDOM from 'react-dom';\nimport { mergeAttributes, Node } from '@tiptap/core';\nimport { NodeViewWrapper, ReactNodeViewRenderer } from '@tiptap/react';\nimport MediaDialog from '../plugins/media/media-dialog';\nimport MediaToolbar from '../plugins/media/media-toolbar';\n\nexport const Media = Node.create({\n  name: 'media',\n  group: 'inline',\n  inline: true,\n  atom: true,\n\n  addAttributes() {\n    return {\n      type: { default: 'video' },\n      src: { default: null },\n      width: { default: null },\n      height: { default: null },\n      title: { default: null },\n      starts: { default: null },\n      ends: { default: null },\n      editing: { default: false },\n      tag: { default: 'iframe' }, // 'iframe' or 'audio'\n      url: { default: null },\n    };\n  },\n\n  parseHTML() {\n    return [\n      {\n        tag: 'iframe[data-type=\"video\"]',\n        getAttrs: (el) => ({\n          type: 'video',\n          tag: 'iframe',\n          src: el.getAttribute('src'),\n          width: el.getAttribute('width'),\n          height: el.getAttribute('height'),\n          title: el.dataset.title,\n          starts: el.dataset.starts,\n          ends: el.dataset.ends,\n          url: el.dataset.url,\n        }),\n      },\n      {\n        tag: 'audio',\n        getAttrs: (el) => ({\n          type: 'audio',\n          tag: 'audio',\n          src: el.querySelector('source')?.getAttribute('src'),\n        }),\n      },\n    ];\n  },\n\n  renderHTML({ HTMLAttributes }) {\n    const { tag, src, width, height } = HTMLAttributes;\n\n    if (tag === 'audio') {\n      return ['audio', { controls: 'controls', controlsList: 'nodownload' }, ['source', { src, type: 'audio/mp3' }]];\n    }\n\n    return [\n      'iframe',\n      mergeAttributes(\n        {\n          'data-type': 'video',\n          frameborder: '0',\n          allow: 'accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture',\n          allowfullscreen: '',\n          src,\n        },\n        width ? { width } : {},\n        height ? { height } : {},\n      ),\n    ];\n  },\n\n  addCommands() {\n    return {\n      insertMedia: (attrs) => ({ commands }) => {\n        return commands.insertContent({ type: this.name, attrs });\n      },\n      updateMedia: (attrs) => ({ commands }) => {\n        return commands.updateAttributes(this.name, attrs);\n      },\n    };\n  },\n\n  addNodeView() {\n    return ReactNodeViewRenderer((props) => <MediaNodeView {...{ ...props, options: this.options }} />);\n  },\n});\n\nconst removeDialogs = () => {\n  const prevDialogs = document.querySelectorAll('.insert-media-dialog');\n\n  prevDialogs.forEach((s) => s.remove());\n};\n\nexport const insertDialog = (props) => {\n  const newEl = document.createElement('div');\n  const { type, callback, options, ...rest } = props;\n  const initialBodyOverflow = document.body.style.overflow;\n\n  removeDialogs();\n\n  newEl.className = 'insert-media-dialog';\n  document.body.style.overflow = 'hidden';\n\n  const handleClose = (val, data) => {\n    callback(val, data);\n    newEl.remove();\n    document.body.style.overflow = initialBodyOverflow;\n  };\n\n  const el = (\n    <MediaDialog\n      {...rest}\n      uploadSoundSupport={options.uploadSoundSupport}\n      type={type}\n      disablePortal={true}\n      open={true}\n      handleClose={handleClose}\n    />\n  );\n\n  ReactDOM.render(el, newEl);\n\n  document.body.appendChild(newEl);\n};\n\nexport default function MediaNodeView({ editor, node, updateAttributes, deleteNode, options }) {\n  const { type, src, width, height, tag } = node.attrs;\n\n  const handleEdit = () => {\n    insertDialog({\n      ...node.attrs,\n      edit: true,\n      callback: (val, data) => {\n        if (val) {\n          updateAttributes(data);\n        } else {\n          deleteNode();\n        }\n\n        editor.chain().focus().run();\n      },\n    });\n  };\n\n  useEffect(() => {\n    insertDialog({\n      ...node.attrs,\n      options: options,\n      edit: true,\n      callback: (val, data) => {\n        if (val) {\n          updateAttributes(data);\n        } else {\n          deleteNode();\n        }\n\n        editor.chain().focus().run();\n      },\n    });\n  }, []);\n\n  return (\n    <NodeViewWrapper data-type={type} style={{ width, height }}>\n      {tag === 'audio' ? (\n        <audio controls controlsList=\"nodownload\">\n          <source src={src} />\n        </audio>\n      ) : (\n        <iframe src={src} allowFullScreen frameBorder=\"0\" />\n      )}\n\n      <MediaToolbar onEdit={handleEdit} onRemove={deleteNode} />\n    </NodeViewWrapper>\n  );\n}\n"]}