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

package/lib/extensions/css.js

@@ -0,0 +1,252 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeDialogs = exports.CSSMark = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactDom = _interopRequireDefault(require("react-dom"));
+
+var _core = require("@tiptap/core");
+
+var _List = _interopRequireDefault(require("@material-ui/core/List"));
+
+var _ListItem = _interopRequireDefault(require("@material-ui/core/ListItem"));
+
+var removeDialogs = function removeDialogs() {
+  var prevDialogs = document.querySelectorAll('.insert-css-dialog');
+  prevDialogs.forEach(function (s) {
+    return s.remove();
+  });
+};
+
+exports.removeDialogs = removeDialogs;
+
+var insertDialog = function insertDialog(_ref) {
+  var editor = _ref.editor,
+      callback = _ref.callback,
+      opts = _ref.opts,
+      selectedText = _ref.selectedText,
+      parentNode = _ref.parentNode;
+  var editorDOM = editor.options.element;
+  var newEl = document.createElement('div');
+  var selection = editor.state.selection;
+  removeDialogs();
+  newEl.className = 'insert-css-dialog';
+  var popoverEl;
+
+  var closePopOver = function closePopOver() {
+    if (popoverEl) {
+      popoverEl.remove();
+    }
+  };
+
+  var firstCallMade = false;
+
+  var listener = function listener(e) {
+    // this will be triggered right after setting it because
+    // this toolbar is added on the mousedown event
+    // so right after mouseup, the click will be triggered
+    if (firstCallMade) {
+      var focusIsInModals = newEl.contains(e.target) || popoverEl && popoverEl.contains(e.target);
+      var focusIsInEditor = editorDOM.contains(e.target);
+
+      if (!(focusIsInModals || focusIsInEditor)) {
+        handleClose();
+      }
+    } else {
+      firstCallMade = true;
+    }
+  };
+
+  var handleClose = function handleClose() {
+    callback(undefined, true);
+    newEl.remove();
+    closePopOver();
+    document.body.removeEventListener('click', listener);
+  };
+
+  var handleChange = function handleChange(name) {
+    callback(name, true);
+    newEl.remove();
+    closePopOver();
+    document.body.removeEventListener('click', listener);
+  };
+
+  var parentNodeClass = parentNode === null || parentNode === void 0 ? void 0 : parentNode.attrs["class"];
+
+  var createHTML = function createHTML(name) {
+    var html = "<span class=\"".concat(name, "\">").concat(selectedText, "</span>");
+
+    if (parentNode) {
+      var tag = 'span';
+
+      if ((parentNode === null || parentNode === void 0 ? void 0 : parentNode.object) === 'inline') {
+        tag = 'span';
+      }
+
+      if ((parentNode === null || parentNode === void 0 ? void 0 : parentNode.object) === 'block') {
+        tag = 'div';
+      }
+
+      html = "<".concat(tag, " class=\"").concat(parentNodeClass, "\">").concat(parentNode.text.slice(0, selection.$anchor.textOffset)).concat(html).concat(parentNode.text.slice(selection.$head.textOffset), "</").concat(tag, ">");
+    }
+
+    return html;
+  };
+
+  var el = /*#__PURE__*/_react["default"].createElement("div", {
+    style: {
+      background: 'white',
+      height: 500,
+      padding: 20,
+      overflow: 'hidden',
+      display: 'flex',
+      flexFlow: 'column'
+    }
+  }, /*#__PURE__*/_react["default"].createElement("h2", null, "Please choose a css class"), parentNodeClass && /*#__PURE__*/_react["default"].createElement("div", null, "The current parent has this class ", parentNodeClass), /*#__PURE__*/_react["default"].createElement(_List["default"], {
+    component: "nav",
+    style: {
+      overflow: 'scroll'
+    }
+  }, opts.names.map(function (name, i) {
+    return /*#__PURE__*/_react["default"].createElement(_ListItem["default"], {
+      key: "rule-".concat(i),
+      button: true,
+      onClick: function onClick() {
+        return handleChange(name);
+      }
+    }, /*#__PURE__*/_react["default"].createElement("div", {
+      style: {
+        marginRight: 20
+      }
+    }, name), /*#__PURE__*/_react["default"].createElement("div", {
+      dangerouslySetInnerHTML: {
+        __html: createHTML(name)
+      }
+    }));
+  })));
+
+  _reactDom["default"].render(el, newEl, function () {
+    var cursorItem = editor.view.nodeDOM(editor.state.selection.from);
+    var cursorNode = cursorItem === null || cursorItem === void 0 ? void 0 : cursorItem.parentNode;
+
+    if (cursorNode) {
+      var bodyRect = editorDOM.parentElement.parentElement.parentElement.getBoundingClientRect();
+      var boundRect = cursorNode.getBoundingClientRect();
+      editorDOM.parentElement.parentElement.parentElement.appendChild(newEl);
+      newEl.style.maxWidth = '500px';
+      newEl.style.position = 'absolute';
+      newEl.style.top = 0;
+      newEl.style.zIndex = 99999;
+      var leftValue = "".concat(boundRect.left + Math.abs(bodyRect.left) + cursorNode.offsetWidth + 10, "px");
+      var rightValue = "".concat(boundRect.x, "px");
+      newEl.style.left = leftValue;
+      var leftAlignedWidth = newEl.offsetWidth;
+      newEl.style.left = 'unset';
+      newEl.style.right = rightValue;
+      var rightAlignedWidth = newEl.offsetWidth;
+      newEl.style.left = 'unset';
+      newEl.style.right = 'unset';
+
+      if (leftAlignedWidth >= rightAlignedWidth) {
+        newEl.style.left = leftValue;
+      } else {
+        newEl.style.right = rightValue;
+      }
+
+      document.body.addEventListener('click', listener);
+    }
+  });
+};
+
+var CSSMark = _core.Mark.create({
+  name: 'cssmark',
+  addOptions: function addOptions() {
+    return {
+      classes: []
+    };
+  },
+  addAttributes: function addAttributes() {
+    return {
+      "class": {
+        "default": null,
+        parseHTML: function parseHTML(el) {
+          return el.getAttribute('class');
+        },
+        renderHTML: function renderHTML(attributes) {
+          if (!attributes["class"]) return {};
+          return {
+            "class": attributes["class"]
+          };
+        }
+      }
+    };
+  },
+  parseHTML: function parseHTML() {
+    var _this = this;
+
+    // Any span with a class that matches one of allowed classes
+    return [{
+      tag: 'span[class]',
+      getAttrs: function getAttrs(el) {
+        var cls = el.getAttribute('class') || '';
+
+        var match = _this.options.classes.find(function (name) {
+          return cls.includes(name);
+        });
+
+        return match ? {
+          "class": match
+        } : false;
+      }
+    }];
+  },
+  renderHTML: function renderHTML(_ref2) {
+    var HTMLAttributes = _ref2.HTMLAttributes;
+    return ['span', (0, _core.mergeAttributes)(HTMLAttributes), 0];
+  },
+  addCommands: function addCommands() {
+    var _this2 = this;
+
+    return {
+      setCSSClass: function setCSSClass(className) {
+        return function (_ref3) {
+          var commands = _ref3.commands;
+          return commands.setMark(_this2.name, {
+            "class": className
+          });
+        };
+      },
+      unsetCSSClass: function unsetCSSClass() {
+        return function (_ref4) {
+          var commands = _ref4.commands;
+          return commands.unsetMark(_this2.name);
+        };
+      },
+      openCSSClassDialog: function openCSSClassDialog() {
+        return function (_ref5) {
+          var editor = _ref5.editor;
+          insertDialog({
+            editor: editor,
+            selectedText: editor.state.doc.textBetween(editor.state.selection.from, editor.state.selection.to),
+            parentNode: editor.state.selection.$from.nodeAfter,
+            opts: _this2.options.extraCSSRules,
+            callback: function callback(className) {
+              if (className) {
+                editor.chain().focus().setCSSClass(className).run();
+              }
+            }
+          });
+        };
+      }
+    };
+  }
+});
+
+exports.CSSMark = CSSMark;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/extensions/css.js"],"names":["removeDialogs","prevDialogs","document","querySelectorAll","forEach","s","remove","insertDialog","editor","callback","opts","selectedText","parentNode","editorDOM","options","element","newEl","createElement","selection","state","className","popoverEl","closePopOver","firstCallMade","listener","e","focusIsInModals","contains","target","focusIsInEditor","handleClose","undefined","body","removeEventListener","handleChange","name","parentNodeClass","attrs","createHTML","html","tag","object","text","slice","$anchor","textOffset","$head","el","background","height","padding","overflow","display","flexFlow","names","map","i","marginRight","__html","ReactDOM","render","cursorItem","view","nodeDOM","from","cursorNode","bodyRect","parentElement","getBoundingClientRect","boundRect","appendChild","style","maxWidth","position","top","zIndex","leftValue","left","Math","abs","offsetWidth","rightValue","x","leftAlignedWidth","right","rightAlignedWidth","addEventListener","CSSMark","Mark","create","addOptions","classes","addAttributes","parseHTML","getAttribute","renderHTML","attributes","getAttrs","cls","match","find","includes","HTMLAttributes","addCommands","setCSSClass","commands","setMark","unsetCSSClass","unsetMark","openCSSClassDialog","doc","textBetween","to","$from","nodeAfter","extraCSSRules","chain","focus","run"],"mappings":"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","sourcesContent":["import React from 'react';\nimport ReactDOM from 'react-dom';\nimport { Mark, mergeAttributes } from '@tiptap/core';\nimport List from '@material-ui/core/List';\nimport ListItem from '@material-ui/core/ListItem';\n\nexport const removeDialogs = () => {\n  const prevDialogs = document.querySelectorAll('.insert-css-dialog');\n\n  prevDialogs.forEach((s) => s.remove());\n};\n\nconst insertDialog = ({ editor, callback, opts, selectedText, parentNode }) => {\n  const editorDOM = editor.options.element;\n  const newEl = document.createElement('div');\n  const { selection } = editor.state;\n\n  removeDialogs();\n\n  newEl.className = 'insert-css-dialog';\n\n  let popoverEl;\n\n  const closePopOver = () => {\n    if (popoverEl) {\n      popoverEl.remove();\n    }\n  };\n\n  let firstCallMade = false;\n\n  const listener = (e) => {\n    // this will be triggered right after setting it because\n    // this toolbar is added on the mousedown event\n    // so right after mouseup, the click will be triggered\n    if (firstCallMade) {\n      const focusIsInModals = newEl.contains(e.target) || (popoverEl && popoverEl.contains(e.target));\n      const focusIsInEditor = editorDOM.contains(e.target);\n\n      if (!(focusIsInModals || focusIsInEditor)) {\n        handleClose();\n      }\n    } else {\n      firstCallMade = true;\n    }\n  };\n\n  const handleClose = () => {\n    callback(undefined, true);\n    newEl.remove();\n    closePopOver();\n    document.body.removeEventListener('click', listener);\n  };\n\n  const handleChange = (name) => {\n    callback(name, true);\n    newEl.remove();\n    closePopOver();\n    document.body.removeEventListener('click', listener);\n  };\n\n  const parentNodeClass = parentNode?.attrs.class;\n  const createHTML = (name) => {\n    let html = `<span class=\"${name}\">${selectedText}</span>`;\n\n    if (parentNode) {\n      let tag = 'span';\n\n      if (parentNode?.object === 'inline') {\n        tag = 'span';\n      }\n\n      if (parentNode?.object === 'block') {\n        tag = 'div';\n      }\n\n      html = `<${tag} class=\"${parentNodeClass}\">${parentNode.text.slice(0, selection.$anchor.textOffset)}${html}${parentNode.text.slice(\n        selection.$head.textOffset,\n      )}</${tag}>`;\n    }\n\n    return html;\n  };\n\n  const el = (\n    <div\n      style={{ background: 'white', height: 500, padding: 20, overflow: 'hidden', display: 'flex', flexFlow: 'column' }}\n    >\n      <h2>Please choose a css class</h2>\n      {parentNodeClass && <div>The current parent has this class {parentNodeClass}</div>}\n      <List component=\"nav\" style={{ overflow: 'scroll' }}>\n        {opts.names.map((name, i) => (\n          <ListItem key={`rule-${i}`} button onClick={() => handleChange(name)}>\n            <div style={{ marginRight: 20 }}>{name}</div>\n            <div\n              dangerouslySetInnerHTML={{\n                __html: createHTML(name),\n              }}\n            />\n          </ListItem>\n        ))}\n      </List>\n    </div>\n  );\n\n  ReactDOM.render(el, newEl, () => {\n    const cursorItem = editor.view.nodeDOM(editor.state.selection.from);\n    const cursorNode = cursorItem?.parentNode;\n\n    if (cursorNode) {\n      const bodyRect = editorDOM.parentElement.parentElement.parentElement.getBoundingClientRect();\n      const boundRect = cursorNode.getBoundingClientRect();\n\n      editorDOM.parentElement.parentElement.parentElement.appendChild(newEl);\n\n      newEl.style.maxWidth = '500px';\n      newEl.style.position = 'absolute';\n      newEl.style.top = 0;\n      newEl.style.zIndex = 99999;\n\n      const leftValue = `${boundRect.left + Math.abs(bodyRect.left) + cursorNode.offsetWidth + 10}px`;\n\n      const rightValue = `${boundRect.x}px`;\n\n      newEl.style.left = leftValue;\n\n      const leftAlignedWidth = newEl.offsetWidth;\n\n      newEl.style.left = 'unset';\n      newEl.style.right = rightValue;\n\n      const rightAlignedWidth = newEl.offsetWidth;\n\n      newEl.style.left = 'unset';\n      newEl.style.right = 'unset';\n\n      if (leftAlignedWidth >= rightAlignedWidth) {\n        newEl.style.left = leftValue;\n      } else {\n        newEl.style.right = rightValue;\n      }\n\n      document.body.addEventListener('click', listener);\n    }\n  });\n};\n\nexport const CSSMark = Mark.create({\n  name: 'cssmark',\n\n  addOptions() {\n    return {\n      classes: [],\n    };\n  },\n\n  addAttributes() {\n    return {\n      class: {\n        default: null,\n        parseHTML: (el) => el.getAttribute('class'),\n        renderHTML: (attributes) => {\n          if (!attributes.class) return {};\n          return { class: attributes.class };\n        },\n      },\n    };\n  },\n\n  parseHTML() {\n    // Any span with a class that matches one of allowed classes\n    return [\n      {\n        tag: 'span[class]',\n        getAttrs: (el) => {\n          const cls = el.getAttribute('class') || '';\n          const match = this.options.classes.find((name) => cls.includes(name));\n          return match ? { class: match } : false;\n        },\n      },\n    ];\n  },\n\n  renderHTML({ HTMLAttributes }) {\n    return ['span', mergeAttributes(HTMLAttributes), 0];\n  },\n\n  addCommands() {\n    return {\n      setCSSClass: (className) => ({ commands }) => {\n        return commands.setMark(this.name, { class: className });\n      },\n\n      unsetCSSClass: () => ({ commands }) => {\n        return commands.unsetMark(this.name);\n      },\n\n      openCSSClassDialog: () => ({ editor }) => {\n        insertDialog({\n          editor,\n          selectedText: editor.state.doc.textBetween(editor.state.selection.from, editor.state.selection.to),\n          parentNode: editor.state.selection.$from.nodeAfter,\n          opts: this.options.extraCSSRules,\n          callback: (className) => {\n            if (className) {\n              editor\n                .chain()\n                .focus()\n                .setCSSClass(className)\n                .run();\n            }\n          },\n        });\n      },\n    };\n  },\n});\n"]}

package/lib/extensions/custom-toolbar-wrapper.js

@@ -0,0 +1,124 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _IconButton = _interopRequireDefault(require("@material-ui/core/IconButton"));
+
+var _Delete = _interopRequireDefault(require("@material-ui/icons/Delete"));
+
+var _doneButton = require("../plugins/toolbar/done-button");
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _constants = require("../constants");
+
+var _styles = require("@material-ui/core/styles");
+
+var _toolbar = require("../plugins/toolbar/toolbar");
+
+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; }
+
+function CustomToolbarWrapper(props) {
+  var _classNames;
+
+  var children = props.children,
+      deletable = props.deletable,
+      classes = props.classes,
+      toolbarOpts = props.toolbarOpts,
+      autoWidth = props.autoWidth,
+      isFocused = props.isFocused,
+      doneButtonRef = props.doneButtonRef,
+      onDelete = props.onDelete,
+      showDone = props.showDone,
+      onDone = props.onDone;
+  var names = (0, _classnames["default"])(classes.toolbar, _constants.PIE_TOOLBAR__CLASS, (_classNames = {}, (0, _defineProperty2["default"])(_classNames, classes.toolbarWithNoDone, !showDone), (0, _defineProperty2["default"])(_classNames, classes.toolbarRight, toolbarOpts.alignment === 'right'), (0, _defineProperty2["default"])(_classNames, classes.focused, toolbarOpts.alwaysVisible || isFocused), (0, _defineProperty2["default"])(_classNames, classes.autoWidth, autoWidth), (0, _defineProperty2["default"])(_classNames, classes.fullWidth, !autoWidth), (0, _defineProperty2["default"])(_classNames, classes.hidden, toolbarOpts.isHidden === true), _classNames));
+  var customStyles = toolbarOpts.minWidth !== undefined ? {
+    minWidth: toolbarOpts.minWidth
+  } : {};
+  return /*#__PURE__*/_react["default"].createElement("div", {
+    className: names,
+    style: _objectSpread({}, customStyles)
+  }, children, /*#__PURE__*/_react["default"].createElement("div", {
+    className: classes.shared
+  }, deletable && /*#__PURE__*/_react["default"].createElement(_IconButton["default"], {
+    "aria-label": "Delete",
+    className: classes.iconRoot,
+    onMouseDown: function onMouseDown(e) {
+      return onDelete === null || onDelete === void 0 ? void 0 : onDelete(e);
+    },
+    classes: {
+      root: classes.iconRoot
+    }
+  }, /*#__PURE__*/_react["default"].createElement(_Delete["default"], null)), showDone && /*#__PURE__*/_react["default"].createElement(_doneButton.DoneButton, {
+    doneButtonRef: doneButtonRef,
+    onClick: onDone
+  })));
+}
+
+var style = {
+  toolbar: {
+    position: 'absolute',
+    zIndex: 10,
+    cursor: 'pointer',
+    justifyContent: 'space-between',
+    background: 'var(--editable-html-toolbar-bg, #efefef)',
+    minWidth: '280px',
+    margin: '5px 0 0 0',
+    padding: '2px',
+    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)',
+    boxSizing: 'border-box',
+    display: 'flex',
+    opacity: 1
+  },
+  toolbarWithNoDone: {
+    minWidth: '265px'
+  },
+  toolbarRight: {
+    right: 0
+  },
+  fullWidth: {
+    width: '100%'
+  },
+  hidden: {
+    visibility: 'hidden'
+  },
+  autoWidth: {
+    width: 'auto'
+  },
+  iconRoot: {
+    width: '28px',
+    height: '28px',
+    padding: '4px',
+    verticalAlign: 'top'
+  },
+  label: {
+    color: 'var(--editable-html-toolbar-check, #00bb00)'
+  },
+  shared: {
+    display: 'flex'
+  }
+};
+
+var _default = (0, _styles.withStyles)(style, {
+  index: 1000
+})(CustomToolbarWrapper);
+
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9leHRlbnNpb25zL2N1c3RvbS10b29sYmFyLXdyYXBwZXIuanN4Il0sIm5hbWVzIjpbIkN1c3RvbVRvb2xiYXJXcmFwcGVyIiwicHJvcHMiLCJjaGlsZHJlbiIsImRlbGV0YWJsZSIsImNsYXNzZXMiLCJ0b29sYmFyT3B0cyIsImF1dG9XaWR0aCIsImlzRm9jdXNlZCIsImRvbmVCdXR0b25SZWYiLCJvbkRlbGV0ZSIsInNob3dEb25lIiwib25Eb25lIiwibmFtZXMiLCJ0b29sYmFyIiwiUElFX1RPT0xCQVJfX0NMQVNTIiwidG9vbGJhcldpdGhOb0RvbmUiLCJ0b29sYmFyUmlnaHQiLCJhbGlnbm1lbnQiLCJmb2N1c2VkIiwiYWx3YXlzVmlzaWJsZSIsImZ1bGxXaWR0aCIsImhpZGRlbiIsImlzSGlkZGVuIiwiY3VzdG9tU3R5bGVzIiwibWluV2lkdGgiLCJ1bmRlZmluZWQiLCJzaGFyZWQiLCJpY29uUm9vdCIsImUiLCJyb290Iiwic3R5bGUiLCJwb3NpdGlvbiIsInpJbmRleCIsImN1cnNvciIsImp1c3RpZnlDb250ZW50IiwiYmFja2dyb3VuZCIsIm1hcmdpbiIsInBhZGRpbmciLCJib3hTaGFkb3ciLCJib3hTaXppbmciLCJkaXNwbGF5Iiwib3BhY2l0eSIsInJpZ2h0Iiwid2lkdGgiLCJ2aXNpYmlsaXR5IiwiaGVpZ2h0IiwidmVydGljYWxBbGlnbiIsImxhYmVsIiwiY29sb3IiLCJpbmRleCJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7OztBQUFBOztBQUNBOztBQUNBOztBQUNBOztBQUNBOztBQUNBOztBQUNBOztBQUNBOzs7Ozs7Ozs7O0FBRUEsU0FBU0Esb0JBQVQsQ0FBOEJDLEtBQTlCLEVBQXFDO0FBQUE7O0FBQ25DLE1BQ0VDLFFBREYsR0FXSUQsS0FYSixDQUNFQyxRQURGO0FBQUEsTUFFRUMsU0FGRixHQVdJRixLQVhKLENBRUVFLFNBRkY7QUFBQSxNQUdFQyxPQUhGLEdBV0lILEtBWEosQ0FHRUcsT0FIRjtBQUFBLE1BSUVDLFdBSkYsR0FXSUosS0FYSixDQUlFSSxXQUpGO0FBQUEsTUFLRUMsU0FMRixHQVdJTCxLQVhKLENBS0VLLFNBTEY7QUFBQSxNQU1FQyxTQU5GLEdBV0lOLEtBWEosQ0FNRU0sU0FORjtBQUFBLE1BT0VDLGFBUEYsR0FXSVAsS0FYSixDQU9FTyxhQVBGO0FBQUEsTUFRRUMsUUFSRixHQVdJUixLQVhKLENBUUVRLFFBUkY7QUFBQSxNQVNFQyxRQVRGLEdBV0lULEtBWEosQ0FTRVMsUUFURjtBQUFBLE1BVUVDLE1BVkYsR0FXSVYsS0FYSixDQVVFVSxNQVZGO0FBWUEsTUFBTUMsS0FBSyxHQUFHLDRCQUFXUixPQUFPLENBQUNTLE9BQW5CLEVBQTRCQyw2QkFBNUIsbUVBQ1hWLE9BQU8sQ0FBQ1csaUJBREcsRUFDaUIsQ0FBQ0wsUUFEbEIsaURBRVhOLE9BQU8sQ0FBQ1ksWUFGRyxFQUVZWCxXQUFXLENBQUNZLFNBQVosS0FBMEIsT0FGdEMsaURBR1hiLE9BQU8sQ0FBQ2MsT0FIRyxFQUdPYixXQUFXLENBQUNjLGFBQVosSUFBNkJaLFNBSHBDLGlEQUlYSCxPQUFPLENBQUNFLFNBSkcsRUFJU0EsU0FKVCxpREFLWEYsT0FBTyxDQUFDZ0IsU0FMRyxFQUtTLENBQUNkLFNBTFYsaURBTVhGLE9BQU8sQ0FBQ2lCLE1BTkcsRUFNTWhCLFdBQVcsQ0FBQ2lCLFFBQVosS0FBeUIsSUFOL0IsZ0JBQWQ7QUFRQSxNQUFNQyxZQUFZLEdBQUdsQixXQUFXLENBQUNtQixRQUFaLEtBQXlCQyxTQUF6QixHQUFxQztBQUFFRCxJQUFBQSxRQUFRLEVBQUVuQixXQUFXLENBQUNtQjtBQUF4QixHQUFyQyxHQUEwRSxFQUEvRjtBQUVBLHNCQUNFO0FBQUssSUFBQSxTQUFTLEVBQUVaLEtBQWhCO0FBQXVCLElBQUEsS0FBSyxvQkFBT1csWUFBUDtBQUE1QixLQUNHckIsUUFESCxlQUdFO0FBQUssSUFBQSxTQUFTLEVBQUVFLE9BQU8sQ0FBQ3NCO0FBQXhCLEtBQ0d2QixTQUFTLGlCQUNSLGdDQUFDLHNCQUFEO0FBQ0Usa0JBQVcsUUFEYjtBQUVFLElBQUEsU0FBUyxFQUFFQyxPQUFPLENBQUN1QixRQUZyQjtBQUdFLElBQUEsV0FBVyxFQUFFLHFCQUFDQyxDQUFEO0FBQUEsYUFBT25CLFFBQVAsYUFBT0EsUUFBUCx1QkFBT0EsUUFBUSxDQUFHbUIsQ0FBSCxDQUFmO0FBQUEsS0FIZjtBQUlFLElBQUEsT0FBTyxFQUFFO0FBQ1BDLE1BQUFBLElBQUksRUFBRXpCLE9BQU8sQ0FBQ3VCO0FBRFA7QUFKWCxrQkFRRSxnQ0FBQyxrQkFBRCxPQVJGLENBRkosRUFhR2pCLFFBQVEsaUJBQUksZ0NBQUMsc0JBQUQ7QUFBWSxJQUFBLGFBQWEsRUFBRUYsYUFBM0I7QUFBMEMsSUFBQSxPQUFPLEVBQUVHO0FBQW5ELElBYmYsQ0FIRixDQURGO0FBcUJEOztBQUVELElBQU1tQixLQUFLLEdBQUc7QUFDWmpCLEVBQUFBLE9BQU8sRUFBRTtBQUNQa0IsSUFBQUEsUUFBUSxFQUFFLFVBREg7QUFFUEMsSUFBQUEsTUFBTSxFQUFFLEVBRkQ7QUFHUEMsSUFBQUEsTUFBTSxFQUFFLFNBSEQ7QUFJUEMsSUFBQUEsY0FBYyxFQUFFLGVBSlQ7QUFLUEMsSUFBQUEsVUFBVSxFQUFFLDBDQUxMO0FBTVBYLElBQUFBLFFBQVEsRUFBRSxPQU5IO0FBT1BZLElBQUFBLE1BQU0sRUFBRSxXQVBEO0FBUVBDLElBQUFBLE9BQU8sRUFBRSxLQVJGO0FBU1BDLElBQUFBLFNBQVMsRUFDUCwrR0FWSztBQVdQQyxJQUFBQSxTQUFTLEVBQUUsWUFYSjtBQVlQQyxJQUFBQSxPQUFPLEVBQUUsTUFaRjtBQWFQQyxJQUFBQSxPQUFPLEVBQUU7QUFiRixHQURHO0FBZ0JaMUIsRUFBQUEsaUJBQWlCLEVBQUU7QUFDakJTLElBQUFBLFFBQVEsRUFBRTtBQURPLEdBaEJQO0FBbUJaUixFQUFBQSxZQUFZLEVBQUU7QUFDWjBCLElBQUFBLEtBQUssRUFBRTtBQURLLEdBbkJGO0FBc0JadEIsRUFBQUEsU0FBUyxFQUFFO0FBQ1R1QixJQUFBQSxLQUFLLEVBQUU7QUFERSxHQXRCQztBQXlCWnRCLEVBQUFBLE1BQU0sRUFBRTtBQUNOdUIsSUFBQUEsVUFBVSxFQUFFO0FBRE4sR0F6Qkk7QUE0Qlp0QyxFQUFBQSxTQUFTLEVBQUU7QUFDVHFDLElBQUFBLEtBQUssRUFBRTtBQURFLEdBNUJDO0FBK0JaaEIsRUFBQUEsUUFBUSxFQUFFO0FBQ1JnQixJQUFBQSxLQUFLLEVBQUUsTUFEQztBQUVSRSxJQUFBQSxNQUFNLEVBQUUsTUFGQTtBQUdSUixJQUFBQSxPQUFPLEVBQUUsS0FIRDtBQUlSUyxJQUFBQSxhQUFhLEVBQUU7QUFKUCxHQS9CRTtBQXFDWkMsRUFBQUEsS0FBSyxFQUFFO0FBQ0xDLElBQUFBLEtBQUssRUFBRTtBQURGLEdBckNLO0FBd0NadEIsRUFBQUEsTUFBTSxFQUFFO0FBQ05jLElBQUFBLE9BQU8sRUFBRTtBQURIO0FBeENJLENBQWQ7O2VBNENlLHdCQUFXVixLQUFYLEVBQWtCO0FBQUVtQixFQUFBQSxLQUFLLEVBQUU7QUFBVCxDQUFsQixFQUFtQ2pELG9CQUFuQyxDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0LCB7IHVzZUNhbGxiYWNrIH0gZnJvbSAncmVhY3QnO1xuaW1wb3J0IEljb25CdXR0b24gZnJvbSBcIkBtYXRlcmlhbC11aS9jb3JlL0ljb25CdXR0b25cIjtcbmltcG9ydCBEZWxldGUgZnJvbSBcIkBtYXRlcmlhbC11aS9pY29ucy9EZWxldGVcIjtcbmltcG9ydCB7IERvbmVCdXR0b24gfSBmcm9tIFwiLi4vcGx1Z2lucy90b29sYmFyL2RvbmUtYnV0dG9uXCI7XG5pbXBvcnQgY2xhc3NOYW1lcyBmcm9tIFwiY2xhc3NuYW1lc1wiO1xuaW1wb3J0IHsgUElFX1RPT0xCQVJfX0NMQVNTIH0gZnJvbSBcIi4uL2NvbnN0YW50c1wiO1xuaW1wb3J0IHsgd2l0aFN0eWxlcyB9IGZyb20gXCJAbWF0ZXJpYWwtdWkvY29yZS9zdHlsZXNcIjtcbmltcG9ydCB7IFRvb2xiYXIgfSBmcm9tIFwiLi4vcGx1Z2lucy90b29sYmFyL3Rvb2xiYXJcIjtcblxuZnVuY3Rpb24gQ3VzdG9tVG9vbGJhcldyYXBwZXIocHJvcHMpIHtcbiAgY29uc3Qge1xuICAgIGNoaWxkcmVuLFxuICAgIGRlbGV0YWJsZSxcbiAgICBjbGFzc2VzLFxuICAgIHRvb2xiYXJPcHRzLFxuICAgIGF1dG9XaWR0aCxcbiAgICBpc0ZvY3VzZWQsXG4gICAgZG9uZUJ1dHRvblJlZixcbiAgICBvbkRlbGV0ZSxcbiAgICBzaG93RG9uZSxcbiAgICBvbkRvbmUsXG4gIH0gPSBwcm9wcztcbiAgY29uc3QgbmFtZXMgPSBjbGFzc05hbWVzKGNsYXNzZXMudG9vbGJhciwgUElFX1RPT0xCQVJfX0NMQVNTLCB7XG4gICAgW2NsYXNzZXMudG9vbGJhcldpdGhOb0RvbmVdOiAhc2hvd0RvbmUsXG4gICAgW2NsYXNzZXMudG9vbGJhclJpZ2h0XTogdG9vbGJhck9wdHMuYWxpZ25tZW50ID09PSAncmlnaHQnLFxuICAgIFtjbGFzc2VzLmZvY3VzZWRdOiB0b29sYmFyT3B0cy5hbHdheXNWaXNpYmxlIHx8IGlzRm9jdXNlZCxcbiAgICBbY2xhc3Nlcy5hdXRvV2lkdGhdOiBhdXRvV2lkdGgsXG4gICAgW2NsYXNzZXMuZnVsbFdpZHRoXTogIWF1dG9XaWR0aCxcbiAgICBbY2xhc3Nlcy5oaWRkZW5dOiB0b29sYmFyT3B0cy5pc0hpZGRlbiA9PT0gdHJ1ZSxcbiAgfSk7XG4gIGNvbnN0IGN1c3RvbVN0eWxlcyA9IHRvb2xiYXJPcHRzLm1pbldpZHRoICE9PSB1bmRlZmluZWQgPyB7IG1pbldpZHRoOiB0b29sYmFyT3B0cy5taW5XaWR0aCB9IDoge307XG5cbiAgcmV0dXJuIChcbiAgICA8ZGl2IGNsYXNzTmFtZT17bmFtZXN9IHN0eWxlPXt7IC4uLmN1c3RvbVN0eWxlcyB9fT5cbiAgICAgIHtjaGlsZHJlbn1cblxuICAgICAgPGRpdiBjbGFzc05hbWU9e2NsYXNzZXMuc2hhcmVkfT5cbiAgICAgICAge2RlbGV0YWJsZSAmJiAoXG4gICAgICAgICAgPEljb25CdXR0b25cbiAgICAgICAgICAgIGFyaWEtbGFiZWw9XCJEZWxldGVcIlxuICAgICAgICAgICAgY2xhc3NOYW1lPXtjbGFzc2VzLmljb25Sb290fVxuICAgICAgICAgICAgb25Nb3VzZURvd249eyhlKSA9PiBvbkRlbGV0ZT8uKGUpfVxuICAgICAgICAgICAgY2xhc3Nlcz17e1xuICAgICAgICAgICAgICByb290OiBjbGFzc2VzLmljb25Sb290LFxuICAgICAgICAgICAgfX1cbiAgICAgICAgICA+XG4gICAgICAgICAgICA8RGVsZXRlIC8+XG4gICAgICAgICAgPC9JY29uQnV0dG9uPlxuICAgICAgICApfVxuICAgICAgICB7c2hvd0RvbmUgJiYgPERvbmVCdXR0b24gZG9uZUJ1dHRvblJlZj17ZG9uZUJ1dHRvblJlZn0gb25DbGljaz17b25Eb25lfSAvPn1cbiAgICAgIDwvZGl2PlxuICAgIDwvZGl2PlxuICApO1xufVxuXG5jb25zdCBzdHlsZSA9IHtcbiAgdG9vbGJhcjoge1xuICAgIHBvc2l0aW9uOiAnYWJzb2x1dGUnLFxuICAgIHpJbmRleDogMTAsXG4gICAgY3Vyc29yOiAncG9pbnRlcicsXG4gICAganVzdGlmeUNvbnRlbnQ6ICdzcGFjZS1iZXR3ZWVuJyxcbiAgICBiYWNrZ3JvdW5kOiAndmFyKC0tZWRpdGFibGUtaHRtbC10b29sYmFyLWJnLCAjZWZlZmVmKScsXG4gICAgbWluV2lkdGg6ICcyODBweCcsXG4gICAgbWFyZ2luOiAnNXB4IDAgMCAwJyxcbiAgICBwYWRkaW5nOiAnMnB4JyxcbiAgICBib3hTaGFkb3c6XG4gICAgICAnMHB4IDFweCA1cHggMHB4IHJnYmEoMCwgMCwgMCwgMC4yKSwgMHB4IDJweCAycHggMHB4IHJnYmEoMCwgMCwgMCwgMC4xNCksIDBweCAzcHggMXB4IC0ycHggcmdiYSgwLCAwLCAwLCAwLjEyKScsXG4gICAgYm94U2l6aW5nOiAnYm9yZGVyLWJveCcsXG4gICAgZGlzcGxheTogJ2ZsZXgnLFxuICAgIG9wYWNpdHk6IDEsXG4gIH0sXG4gIHRvb2xiYXJXaXRoTm9Eb25lOiB7XG4gICAgbWluV2lkdGg6ICcyNjVweCcsXG4gIH0sXG4gIHRvb2xiYXJSaWdodDoge1xuICAgIHJpZ2h0OiAwLFxuICB9LFxuICBmdWxsV2lkdGg6IHtcbiAgICB3aWR0aDogJzEwMCUnLFxuICB9LFxuICBoaWRkZW46IHtcbiAgICB2aXNpYmlsaXR5OiAnaGlkZGVuJyxcbiAgfSxcbiAgYXV0b1dpZHRoOiB7XG4gICAgd2lkdGg6ICdhdXRvJyxcbiAgfSxcbiAgaWNvblJvb3Q6IHtcbiAgICB3aWR0aDogJzI4cHgnLFxuICAgIGhlaWdodDogJzI4cHgnLFxuICAgIHBhZGRpbmc6ICc0cHgnLFxuICAgIHZlcnRpY2FsQWxpZ246ICd0b3AnLFxuICB9LFxuICBsYWJlbDoge1xuICAgIGNvbG9yOiAndmFyKC0tZWRpdGFibGUtaHRtbC10b29sYmFyLWNoZWNrLCAjMDBiYjAwKScsXG4gIH0sXG4gIHNoYXJlZDoge1xuICAgIGRpc3BsYXk6ICdmbGV4JyxcbiAgfSxcbn07XG5leHBvcnQgZGVmYXVsdCB3aXRoU3R5bGVzKHN0eWxlLCB7IGluZGV4OiAxMDAwIH0pKEN1c3RvbVRvb2xiYXJXcmFwcGVyKTtcbiJdfQ==

package/lib/extensions/image.js

@@ -0,0 +1,106 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ImageUploadNode = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _core = require("@tiptap/core");
+
+var _react = require("@tiptap/react");
+
+var _react2 = _interopRequireWildcard(require("react"));
+
+var _component = _interopRequireDefault(require("./component"));
+
+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; }
+
+// ---- Tiptap Extension ---- //
+var ImageUploadNode = _core.Node.create({
+  name: 'imageUploadNode',
+  group: 'block',
+  atom: true,
+  // ✅ prevents content holes
+  selectable: true,
+  // optional
+  draggable: true,
+  // optional
+  addAttributes: function addAttributes() {
+    return {
+      loaded: {
+        "default": false
+      },
+      deleteStatus: {
+        "default": null
+      },
+      alignment: {
+        "default": null
+      },
+      percent: {
+        "default": null
+      },
+      width: {
+        "default": null
+      },
+      height: {
+        "default": null
+      },
+      src: {
+        "default": null
+      },
+      alt: {
+        "default": null
+      }
+    };
+  },
+  parseHTML: function parseHTML() {
+    return [{
+      tag: 'div[data-type="image-upload-node"]'
+    }];
+  },
+  // ✅ No `0` here!
+  renderHTML: function renderHTML(_ref) {
+    var HTMLAttributes = _ref.HTMLAttributes;
+    return ['img', (0, _core.mergeAttributes)(HTMLAttributes, {
+      'data-type': 'image-upload-node'
+    })];
+  },
+  addNodeView: function addNodeView() {
+    var _this = this;
+
+    return (0, _react.ReactNodeViewRenderer)(function (props) {
+      return /*#__PURE__*/_react2["default"].createElement(_component["default"], _objectSpread(_objectSpread({}, props), {}, {
+        options: _this.options
+      }));
+    });
+  },
+  addCommands: function addCommands() {
+    var _this2 = this;
+
+    return {
+      setImageUploadNode: function setImageUploadNode() {
+        return function (_ref2) {
+          var commands = _ref2.commands;
+          return commands.insertContent({
+            type: _this2.name
+          });
+        };
+      }
+    };
+  }
+});
+
+exports.ImageUploadNode = ImageUploadNode;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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