@seafile/sdoc-editor 3.0.113 → 3.0.115

package/dist/extension/plugins/toggle-header/helper.js

@@ -0,0 +1,189 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isOnlyHasToggleContent = exports.insertToggleHeader = exports.getTitleTypeByLevel = exports.getLevelFromType = exports.getLevel = exports.getFirstTextPoint = exports.findFirstTitleNode = exports.ensureToggleContentNotEmpty = void 0;
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createForOfIteratorHelper"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _slate = require("@seafile/slate");
+var _slugid = _interopRequireDefault(require("slugid"));
+var _constants = require("../../constants");
+var _core = require("../../core");
+var getLevelFromType = exports.getLevelFromType = function getLevelFromType(eleType) {
+  if (!eleType) return '';
+  var matched = String(eleType).match(/toggle_header(\d)$/);
+  return matched ? matched[1] : '';
+};
+var getLevel = exports.getLevel = function getLevel(element) {
+  var rawLevel = Number(getLevelFromType(element.type));
+  return Math.min(6, Math.max(1, rawLevel));
+};
+var getTitleTypeByLevel = exports.getTitleTypeByLevel = function getTitleTypeByLevel(level) {
+  var safeLevel = Math.min(6, Math.max(1, Number(level)));
+  return _constants.TOGGLE_TITLE_TYPES[safeLevel - 1];
+};
+var insertToggleHeader = exports.insertToggleHeader = function insertToggleHeader(editor, type, insertPosition) {
+  if (!editor.selection) return;
+  if (typeof editor.canInsertToggleHeader === 'function' && !editor.canInsertToggleHeader()) {
+    return;
+  }
+  var toggleHeader = {
+    id: _slugid["default"].nice(),
+    type: _constants.TOGGLE_HEADER,
+    collapsed: false,
+    children: [{
+      id: _slugid["default"].nice(),
+      type: type,
+      children: [{
+        text: '',
+        id: _slugid["default"].nice()
+      }]
+    }, {
+      id: _slugid["default"].nice(),
+      type: _constants.TOGGLE_CONTENT,
+      children: [{
+        id: _slugid["default"].nice(),
+        type: _constants.PARAGRAPH,
+        children: [{
+          text: '',
+          id: _slugid["default"].nice()
+        }]
+      }]
+    }]
+  };
+  var _Editor$above = _slate.Editor.above(editor, {
+      at: editor.selection,
+      match: function match(n) {
+        return _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n);
+      },
+      mode: 'lowest'
+    }),
+    _Editor$above2 = (0, _slicedToArray2["default"])(_Editor$above, 2),
+    currentBlockPath = _Editor$above2[1];
+  if (!currentBlockPath) return;
+  var toggleContentEntry = _slate.Editor.above(editor, {
+    at: editor.selection,
+    match: function match(n) {
+      return _slate.Element.isElement(n) && n.type === _constants.TOGGLE_CONTENT;
+    },
+    mode: 'lowest'
+  });
+
+  // Support inserting toggle header inside toggle content
+  if (toggleContentEntry) {
+    var _insertAt = _slate.Path.next(currentBlockPath);
+    _slate.Transforms.insertNodes(editor, toggleHeader, {
+      at: _insertAt
+    });
+    var _point = _slate.Editor.start(editor, [].concat((0, _toConsumableArray2["default"])(_insertAt), [0, 0]));
+    _slate.Transforms.select(editor, _point);
+    (0, _core.focusEditor)(editor, _point);
+    return;
+  }
+  var topLevelEntry = _slate.Editor.above(editor, {
+    at: editor.selection,
+    match: function match(n, p) {
+      return _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n) && p.length === 1;
+    }
+  });
+  if (!topLevelEntry) return;
+  var _topLevelEntry = (0, _slicedToArray2["default"])(topLevelEntry, 2),
+    topNode = _topLevelEntry[0],
+    topPath = _topLevelEntry[1];
+  var isEmptyParagraph = topNode.type === _constants.PARAGRAPH && _slate.Node.string(topNode) === '';
+  if (insertPosition === _constants.INSERT_POSITION.CURRENT && isEmptyParagraph) {
+    _slate.Transforms.removeNodes(editor, {
+      at: topPath
+    });
+    _slate.Transforms.insertNodes(editor, toggleHeader, {
+      at: topPath
+    });
+    var _point2 = _slate.Editor.start(editor, [].concat((0, _toConsumableArray2["default"])(topPath), [0, 0]));
+    _slate.Transforms.select(editor, _point2);
+    (0, _core.focusEditor)(editor, _point2);
+    return;
+  }
+  var insertAt = _slate.Path.next(topPath);
+  _slate.Transforms.insertNodes(editor, toggleHeader, {
+    at: insertAt
+  });
+  var point = _slate.Editor.start(editor, [].concat((0, _toConsumableArray2["default"])(insertAt), [0, 0]));
+  _slate.Transforms.select(editor, point);
+  (0, _core.focusEditor)(editor, point);
+};
+var ensureToggleContentNotEmpty = exports.ensureToggleContentNotEmpty = function ensureToggleContentNotEmpty(editor, path) {
+  var node = _slate.Node.get(editor, path);
+  if (node && node.type === _constants.TOGGLE_CONTENT && (!node.children || node.children.length === 0)) {
+    var paragraph = (0, _core.generateEmptyElement)(_constants.PARAGRAPH);
+    _slate.Transforms.insertNodes(editor, paragraph, {
+      at: path.concat(0)
+    });
+  }
+};
+var isOnlyHasToggleContent = exports.isOnlyHasToggleContent = function isOnlyHasToggleContent(node) {
+  var _node$children;
+  if (!node || node.type !== _constants.TOGGLE_HEADER) return false;
+  var hasTitle = false;
+  var hasContent = false;
+  (_node$children = node.children) === null || _node$children === void 0 ? void 0 : _node$children.forEach(function (child) {
+    if (_constants.TOGGLE_TITLE_TYPES.includes(child.type)) {
+      hasTitle = true;
+    }
+    if (child.type === _constants.TOGGLE_CONTENT) {
+      hasContent = true;
+    }
+  });
+  return !hasTitle && hasContent;
+};
+var getFirstTextPoint = exports.getFirstTextPoint = function getFirstTextPoint(editor, targetBlockPath) {
+  var offset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(_slate.Editor.nodes(editor, {
+      at: targetBlockPath,
+      match: function match(n) {
+        return _slate.Text.isText(n);
+      }
+    })),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = (0, _slicedToArray2["default"])(_step.value, 2),
+        node = _step$value[0],
+        path = _step$value[1];
+      var safeOffset = Math.min(offset, node.text.length);
+      return {
+        path: path,
+        offset: safeOffset
+      };
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return null;
+};
+var _findFirstTitleNode = exports.findFirstTitleNode = function findFirstTitleNode(nodes) {
+  if (!Array.isArray(nodes)) return null;
+  var _iterator2 = (0, _createForOfIteratorHelper2["default"])(nodes[0].children),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var node = _step2.value;
+      if (_slate.Element.isElement(node) && _constants.TOGGLE_TITLE_TYPES.includes(node.type)) {
+        return node;
+      }
+      if (node.children) {
+        var inlineNodes = _findFirstTitleNode(node.children);
+        if (inlineNodes) return inlineNodes;
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return null;
+};

package/dist/extension/plugins/toggle-header/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _constants = require("../../constants");
+var _plugin = _interopRequireDefault(require("./plugin"));
+var _renderElem = require("./render-elem");
+var ToggleHeaderPlugin = {
+  type: _constants.TOGGLE_HEADER,
+  nodeType: 'element',
+  editorPlugin: _plugin["default"],
+  renderElements: [_renderElem.renderToggleHeader, _renderElem.renderToggleHeaderTitle, _renderElem.renderToggleHeaderContent]
+};
+var _default = exports["default"] = ToggleHeaderPlugin;

package/dist/extension/plugins/toggle-header/placeholder.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _reactI18next = require("react-i18next");
+var Placeholder = function Placeholder(props) {
+  var title = props.title,
+    _props$top = props.top,
+    top = _props$top === void 0 ? 5 : _props$top,
+    _props$left = props.left,
+    left = _props$left === void 0 ? 20 : _props$left;
+  var _useTranslation = (0, _reactI18next.useTranslation)('sdoc-editor'),
+    t = _useTranslation.t;
+  return /*#__PURE__*/_react["default"].createElement("span", {
+    contentEditable: "false",
+    suppressContentEditableWarning: true,
+    style: {
+      position: 'absolute',
+      top: "".concat(top, "px"),
+      color: 'rgba(191,191,191,1)',
+      pointerEvents: 'none',
+      width: '100%',
+      maxWidth: '100%',
+      display: 'block',
+      userSelect: 'none',
+      textDecoration: 'none',
+      left: "".concat(left, "px")
+    }
+  }, t(title));
+};
+var _default = exports["default"] = Placeholder;