@edtr-io/plugin-text/dist/plugins/katex/index.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createKatexPlugin = exports.removeKatex = exports.insertKatex = exports.isKatex = exports.katexInlineNode = exports.katexBlockNode = void 0;

var _ = require("../..");

var React = _interopRequireWildcard(require("react"));

var _isHotkey = require("is-hotkey");

var _reactMathquill = require("react-mathquill");

var _renderer = require("./renderer");

var _editor = require("./editor");

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }

function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

(0, _reactMathquill.addStyles)();
var katexBlockNode = '@splish-me/katex-block';
exports.katexBlockNode = katexBlockNode;
var katexInlineNode = '@splish-me/katex-inline';
exports.katexInlineNode = katexInlineNode;

var isKatex = function isKatex(editor) {
  return editor.value.blocks.some(function (block) {
    return block ? block.type === katexBlockNode : false;
  }) || editor.value.inlines.some(function (inline) {
    return inline ? inline.type === katexInlineNode : false;
  });
};

exports.isKatex = isKatex;

var insertKatex = function insertKatex(editor) {
  if (editor.value.selection.isExpanded) {
    (0, _.trimSelection)(editor);
    var selection = document.getSelection();
    editor.wrapInline({
      type: katexInlineNode,
      data: {
        formula: selection ? selection.toString() : '',
        inline: true
      }
    }).moveToEnd();
    return editor.focus().moveBackward(1);
  }

  return editor.insertInline({
    type: katexInlineNode,
    data: {
      formula: '',
      inline: true
    }
  });
};

exports.insertKatex = insertKatex;

var removeKatex = function removeKatex(editor) {
  var node = editor.value.blocks.toArray().find(function (block) {
    return block.type === katexBlockNode;
  }) || editor.value.inlines.toArray().find(function (inline) {
    return inline.type === katexInlineNode;
  });
  if (!node) return editor;
  return editor.removeNodeByKey(node.key);
};

exports.removeKatex = removeKatex;

var createKatexPlugin = function createKatexPlugin() {
  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
      _ref$EditorComponent = _ref.EditorComponent,
      EditorComponent = _ref$EditorComponent === void 0 ? _editor.DefaultEditorComponent : _ref$EditorComponent,
      _ref$RenderComponent = _ref.RenderComponent,
      RenderComponent = _ref$RenderComponent === void 0 ? _renderer.DefaultRendererComponent : _ref$RenderComponent;

  return function (pluginClosure) {
    return {
      deserialize: function deserialize(el, next) {
        switch (el.tagName.toLowerCase()) {
          case 'katexblock':
            return {
              object: 'block',
              type: katexBlockNode,
              data: {
                formula: el.childNodes[0].nodeValue,
                inline: false
              },
              nodes: next(el.childNodes)
            };

          case 'katexinline':
            return {
              object: 'inline',
              type: katexInlineNode,
              data: {
                formula: el.childNodes[0].nodeValue,
                inline: true
              },
              nodes: next(el.childNodes)
            };

          default:
            return;
        }
      },
      serialize: function serialize(obj, children) {
        var block = obj;
        var inline = obj;

        if (block.object === 'block' && block.type === katexBlockNode || inline.object === 'inline' && inline.type === katexInlineNode) {
          return React.createElement(RenderComponent, {
            node: obj
          }, children);
        }
      },
      onKeyDown: function onKeyDown(event, editor, next) {
        var e = event;

        if ((0, _isHotkey.isHotkey)('mod+m')(e)) {
          e.preventDefault();
          return insertKatex(editor);
        }

        return next();
      },
      renderNode: function renderNode(props, editor, next) {
        var block = props.node;
        var inline = props.node;
        var name = pluginClosure.current ? pluginClosure.current.name : '';

        if (block.object === 'block' && block.type === katexBlockNode || inline.object === 'inline' && inline.type === katexInlineNode) {
          return React.createElement(EditorComponent, _extends({}, props, {
            editor: editor,
            name: name
          }));
        }

        return next();
      }
    };
  };
};

exports.createKatexPlugin = createKatexPlugin;
//# sourceMappingURL=index.js.map