@seafile/sdoc-editor 2.0.81 → 2.0.83

package/dist/extension/plugins/link/render-elem.js

@@ -0,0 +1,143 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _useScrollContext = require("../../../hooks/use-scroll-context");
+var _eventBus = _interopRequireDefault(require("../../../utils/event-bus"));
+var _InlineBugFixWrapper = _interopRequireDefault(require("../../commons/Inline-bug-fix-wrapper"));
+var _constants2 = require("../../constants");
+var _helpers = require("./helpers");
+var _hover = _interopRequireDefault(require("./hover"));
+var Link = /*#__PURE__*/function (_React$Component) {
+  function Link(props) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, Link);
+    _this = (0, _callSuper2["default"])(this, Link, [props]);
+    (0, _defineProperty2["default"])(_this, "registerEventHandle", function () {
+      document.addEventListener('click', _this.onHideLinkMenu);
+      var scrollRef = _this.context.scrollRef;
+      if (scrollRef.current) {
+        scrollRef.current.addEventListener('scroll', _this.onScroll);
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "unregisterEventHandle", function () {
+      document.removeEventListener('click', _this.onHideLinkMenu);
+      var scrollRef = _this.context.scrollRef;
+      if (scrollRef.current) {
+        scrollRef.current.addEventListener('scroll', _this.onScroll);
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "onHideLinkMenu", function () {
+      _this.setState({
+        isShowLinkMenu: false
+      }, function () {
+        _this.unregisterEventHandle();
+      });
+    });
+    (0, _defineProperty2["default"])(_this, "onScroll", function (e) {
+      _this.setPosition(_this.linkRef);
+    });
+    (0, _defineProperty2["default"])(_this, "setPosition", function (element) {
+      var editor = _this.props.editor;
+      var menuPosition = (0, _helpers.getMenuPosition)(element, editor);
+      _this.setState({
+        menuPosition: menuPosition
+      });
+    });
+    (0, _defineProperty2["default"])(_this, "onLinkClick", function (e) {
+      _this.setPosition(e.target);
+      _this.setState({
+        isShowLinkMenu: true
+      });
+      setTimeout(function () {
+        _this.registerEventHandle();
+      }, 0);
+    });
+    (0, _defineProperty2["default"])(_this, "deleteLink", function (event) {
+      event.stopPropagation();
+      var editor = _this.props.editor;
+      (0, _helpers.unWrapLinkNode)(editor);
+    });
+    (0, _defineProperty2["default"])(_this, "openDialog", function () {
+      var element = _this.props.element;
+      _this.eventBus.dispatch(_constants.INTERNAL_EVENT.INSERT_ELEMENT, {
+        type: _constants2.ELEMENT_TYPE.LINK,
+        element: element
+      });
+    });
+    (0, _defineProperty2["default"])(_this, "setRef", function (ref) {
+      _this.linkRef = ref;
+    });
+    _this.state = {
+      isShowLinkMenu: false,
+      menuPosition: null
+    };
+    _this.eventBus = _eventBus["default"].getInstance();
+    return _this;
+  }
+  (0, _inherits2["default"])(Link, _React$Component);
+  return (0, _createClass2["default"])(Link, [{
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.unregisterEventHandle();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        attributes = _this$props.attributes,
+        children = _this$props.children,
+        element = _this$props.element,
+        editor = _this$props.editor,
+        readonly = _this$props.readonly;
+      var _this$state = this.state,
+        isShowLinkMenu = _this$state.isShowLinkMenu,
+        menuPosition = _this$state.menuPosition;
+      var className = isShowLinkMenu ? 'seafile-ed-hovermenu-mouseclick' : null;
+      if (readonly) {
+        return /*#__PURE__*/_react["default"].createElement("span", Object.assign({
+          className: className
+        }, attributes), /*#__PURE__*/_react["default"].createElement("a", {
+          href: element.href,
+          title: element.title,
+          target: "_blank",
+          rel: "noreferrer"
+        }, children));
+      }
+      return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement("span", Object.assign({
+        className: className
+      }, attributes, {
+        onClick: this.onLinkClick
+      }), /*#__PURE__*/_react["default"].createElement("span", {
+        ref: this.setRef,
+        className: "virtual-link",
+        title: element.title
+      }, /*#__PURE__*/_react["default"].createElement(_InlineBugFixWrapper["default"], null), children, /*#__PURE__*/_react["default"].createElement(_InlineBugFixWrapper["default"], null))), isShowLinkMenu && (this.props.readonly || _slate.Range.isCollapsed(editor.selection)) && /*#__PURE__*/_react["default"].createElement(_hover["default"], {
+        editor: editor,
+        menuPosition: menuPosition,
+        element: element,
+        onDeleteLink: this.deleteLink,
+        onEditLink: this.openDialog
+      }));
+    }
+  }]);
+}(_react["default"].Component);
+(0, _defineProperty2["default"])(Link, "contextType", _useScrollContext.ScrollContext);
+var renderLink = function renderLink(props, editor, readonly) {
+  return /*#__PURE__*/_react["default"].createElement(Link, Object.assign({}, props, {
+    editor: editor,
+    readonly: readonly
+  }));
+};
+var _default = exports["default"] = renderLink;

package/dist/extension/plugins/list/helpers.js

@@ -0,0 +1,123 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setListType = exports.isSingleListItem = exports.isMenuDisabled = exports.getListType = exports.getBeforeText = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createForOfIteratorHelper"));
+var _slate = require("@seafile/slate");
+var _constants = require("../../constants");
+var _queries = require("./queries");
+var _transforms = require("./transforms");
+var isMenuDisabled = exports.isMenuDisabled = function isMenuDisabled(editor, readonly) {
+  if (readonly) return true;
+  if (editor.selection == null) return true;
+  var selectedElements = [];
+  var nodeEntries = _slate.Editor.nodes(editor, {
+    universal: true
+  });
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(nodeEntries),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var nodeEntry = _step.value;
+      var _nodeEntry = (0, _slicedToArray2["default"])(nodeEntry, 1),
+        node = _nodeEntry[0];
+      if (_slate.Element.isElement(node)) selectedElements.push(node);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var notMatch = selectedElements.some(function (element) {
+    if (_slate.Editor.isVoid(editor, element) && _slate.Editor.isBlock(editor, element)) return true;
+    var type = element.type;
+    if ([_constants.CODE_LINE, _constants.CODE_BLOCK, _constants.TABLE, _constants.CHECK_LIST_ITEM].includes(type)) return true;
+    return false;
+  });
+  if (notMatch) return true;
+  return false;
+};
+var getListType = exports.getListType = function getListType(editor, type) {
+  var selection = editor.selection;
+  if (!selection) return;
+  var selectedListNodeEntry;
+  if (_slate.Range.isCollapsed(selection)) {
+    var _Editor$nodes = _slate.Editor.nodes(editor, {
+        match: function match(node) {
+          return (0, _queries.getListTypes)().includes(node.type);
+        },
+        mode: 'lowest'
+      }),
+      _Editor$nodes2 = (0, _slicedToArray2["default"])(_Editor$nodes, 1),
+      nodeEntry = _Editor$nodes2[0];
+    selectedListNodeEntry = nodeEntry;
+  } else {
+    var anchor = selection.anchor,
+      focus = selection.focus;
+    var commonNodeEntry = _slate.Node.common(editor, anchor.path, focus.path);
+    //  Select condition:
+    // 1. Select in one list
+    // 2. Select in one list item
+    // 3. Select in one line
+    if ((0, _queries.getListTypes)().includes(commonNodeEntry[0].type)) {
+      // Select in one list
+      selectedListNodeEntry = commonNodeEntry;
+    } else if (commonNodeEntry[0].type === _constants.LIST_ITEM) {
+      // Select in one list item
+      selectedListNodeEntry = _slate.Editor.parent(editor, commonNodeEntry[1]);
+    } else if (_slate.Text.isText(commonNodeEntry[0])) {
+      // Select in one line
+      var _Editor$nodes3 = _slate.Editor.nodes(editor, {
+          at: commonNodeEntry[1],
+          match: function match(node) {
+            return (0, _queries.getListTypes)().includes(node.type);
+          },
+          mode: 'lowest'
+        }),
+        _Editor$nodes4 = (0, _slicedToArray2["default"])(_Editor$nodes3, 1),
+        _nodeEntry2 = _Editor$nodes4[0];
+      selectedListNodeEntry = _nodeEntry2;
+    }
+  }
+  return selectedListNodeEntry ? selectedListNodeEntry[0].type : _constants.PARAGRAPH;
+};
+var setListType = exports.setListType = function setListType(editor, type) {
+  (0, _transforms.toggleList)(editor, type);
+};
+var getBeforeText = exports.getBeforeText = function getBeforeText(editor) {
+  var selection = editor.selection;
+  if (selection == null) return {
+    beforeText: '',
+    range: null
+  };
+  var anchor = selection.anchor;
+  // Find the near text node above the current text
+  var _Editor$above = _slate.Editor.above(editor),
+    _Editor$above2 = (0, _slicedToArray2["default"])(_Editor$above, 2),
+    aboveNodePath = _Editor$above2[1];
+  var aboveNodeStartPoint = _slate.Editor.start(editor, aboveNodePath); // The starting position of the text node
+  var range = {
+    anchor: anchor,
+    focus: aboveNodeStartPoint
+  };
+  var beforeText = _slate.Editor.string(editor, range) || '';
+  return {
+    beforeText: beforeText,
+    range: range
+  };
+};
+var isSingleListItem = exports.isSingleListItem = function isSingleListItem(node) {
+  // ordered_list/unordered_list -> list-item.children -> paragraph
+  //                                                   -> ordered_list/unordered_list
+  if (![_constants.ORDERED_LIST, _constants.UNORDERED_LIST].includes(node.type)) return false;
+  // list children
+  if (node.children.length !== 1) return false;
+  // listItem children
+  var listItem = node.children[0];
+  if (listItem.children.length !== 1) return false;
+  return true;
+};

package/dist/extension/plugins/list/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _menu = _interopRequireDefault(require("./menu"));
+var _plugin = _interopRequireDefault(require("./plugin"));
+var _renderElem = require("./render-elem");
+var ListPlugin = {
+  type: 'list',
+  nodeType: 'element',
+  editorMenus: [_menu["default"]],
+  editorPlugin: _plugin["default"],
+  renderElements: [_renderElem.renderList, _renderElem.renderListItem, _renderElem.renderListLic]
+};
+var _default = exports["default"] = ListPlugin;

package/dist/extension/plugins/list/menu/index.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _commons = require("../../../commons");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _helpers = require("../helpers");
+var ListMenu = /*#__PURE__*/function (_React$Component) {
+  function ListMenu() {
+    var _this;
+    (0, _classCallCheck2["default"])(this, ListMenu);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = (0, _callSuper2["default"])(this, ListMenu, [].concat(args));
+    (0, _defineProperty2["default"])(_this, "isActive", function () {
+      var _this$props = _this.props,
+        editor = _this$props.editor,
+        _this$props$type = _this$props.type,
+        type = _this$props$type === void 0 ? _constants.UNORDERED_LIST : _this$props$type;
+      return (0, _helpers.getListType)(editor, type) === type;
+    });
+    (0, _defineProperty2["default"])(_this, "isDisabled", function () {
+      var _this$props2 = _this.props,
+        editor = _this$props2.editor,
+        readonly = _this$props2.readonly;
+      return (0, _helpers.isMenuDisabled)(editor, readonly);
+    });
+    (0, _defineProperty2["default"])(_this, "onMouseDown", function (e) {
+      e.preventDefault();
+      e.stopPropagation();
+      if (_this.isDisabled()) return;
+      var _this$props3 = _this.props,
+        editor = _this$props3.editor,
+        _this$props3$type = _this$props3.type,
+        type = _this$props3$type === void 0 ? _constants.UNORDERED_LIST : _this$props3$type;
+
+      // 执行命令
+      (0, _helpers.setListType)(editor, type);
+      (0, _core.focusEditor)(editor);
+    });
+    return _this;
+  }
+  (0, _inherits2["default"])(ListMenu, _React$Component);
+  return (0, _createClass2["default"])(ListMenu, [{
+    key: "render",
+    value: function render() {
+      var _this$props4 = this.props,
+        isRichEditor = _this$props4.isRichEditor,
+        className = _this$props4.className,
+        _this$props4$type = _this$props4.type,
+        type = _this$props4$type === void 0 ? _constants.UNORDERED_LIST : _this$props4$type,
+        ariaLabel = _this$props4.ariaLabel;
+      var menuConfig = _constants.MENUS_CONFIG_MAP[type];
+      var props = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({
+        isRichEditor: isRichEditor,
+        className: className,
+        ariaLabel: ariaLabel
+      }, menuConfig), {}, {
+        disabled: this.isDisabled(),
+        isActive: this.isActive(),
+        onMouseDown: this.onMouseDown
+      });
+      return /*#__PURE__*/_react["default"].createElement(_commons.MenuItem, props);
+    }
+  }]);
+}(_react["default"].Component);
+var _default = exports["default"] = ListMenu;

package/dist/extension/plugins/list/model.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateListItem = exports.generateEmptyListItem = exports.generateEmptyListContent = exports.generateEmptyList = exports["default"] = void 0;
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/classCallCheck"));
+var _slugid = _interopRequireDefault(require("slugid"));
+var _constants = require("../../constants");
+var _core = require("../../core");
+var List = /*#__PURE__*/(0, _createClass2["default"])(function List(options) {
+  (0, _classCallCheck2["default"])(this, List);
+  this.type = options.type || _constants.UNORDERED_LIST;
+  this.children = options.children || [{
+    text: ''
+  }];
+});
+var _default = exports["default"] = List;
+var generateEmptyListItem = exports.generateEmptyListItem = function generateEmptyListItem() {
+  return {
+    id: _slugid["default"].nice(),
+    type: _constants.LIST_ITEM,
+    children: []
+  };
+};
+var generateListItem = exports.generateListItem = function generateListItem() {
+  return {
+    id: _slugid["default"].nice(),
+    type: _constants.LIST_ITEM,
+    children: [generateEmptyListContent()]
+  };
+};
+var generateEmptyListContent = exports.generateEmptyListContent = function generateEmptyListContent() {
+  return (0, _core.generateEmptyElement)(_constants.PARAGRAPH);
+};
+var generateEmptyList = exports.generateEmptyList = function generateEmptyList(type) {
+  return {
+    id: _slugid["default"].nice(),
+    type: type,
+    children: []
+  };
+};

package/dist/extension/plugins/list/plugin/index.js

@@ -0,0 +1,140 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _deleteMerge = require("../../../core/transforms/delete-merge");
+var _queries = require("../queries");
+var _transforms = require("../transforms");
+var _isAcrossListItems = require("../transforms/is-across-list-items");
+var _removeListItem = require("../transforms/remove-list-item");
+var _insertBreakList = require("./insert-break-list");
+var _insertFragmentList = require("./insert-fragment-list");
+var _normalizeList = require("./normalize-list");
+var _onTabHandle = require("./on-tab-handle");
+var _shortcut = require("./shortcut");
+var withList = function withList(editor) {
+  var insertBreak = editor.insertBreak,
+    handleTab = editor.handleTab,
+    insertText = editor.insertText,
+    deleteBackward = editor.deleteBackward;
+  var newEditor = editor;
+  newEditor.insertBreak = function () {
+    if ((0, _insertBreakList.insertBreakList)(editor)) return;
+    insertBreak();
+    return;
+  };
+  newEditor.deleteBackward = function (unit) {
+    var selection = newEditor.selection;
+    if (selection === null) {
+      deleteBackward(unit);
+      return;
+    }
+    var deleteBackwardList = function deleteBackwardList() {
+      var res = (0, _queries.getListItemEntry)(editor, {});
+      var moved = false;
+      if (res) {
+        var list = res.list,
+          listItem = res.listItem;
+        if ((0, _core.isSelectionAtBlockStart)(editor, {
+          match: function match(node) {
+            return node.type === _constants.LIST_ITEM;
+          }
+        })) {
+          _slate.Editor.withoutNormalizing(editor, function () {
+            var moved = (0, _transforms.removeFirstListItem)(editor, {
+              list: list,
+              listItem: listItem
+            });
+            if (moved) return true;
+            moved = (0, _removeListItem.removeListItem)(editor, {
+              list: list,
+              listItem: listItem
+            });
+            if (moved) {
+              setTimeout(function () {
+                var previousLiPath = (0, _core.getPreviousPath)(listItem[1]);
+                (0, _core.focusEditor)(editor, _slate.Editor.end(editor, [].concat((0, _toConsumableArray2["default"])(previousLiPath), [0])));
+              }, 0);
+              return;
+            }
+            if ((0, _core.isFirstChild)(listItem[1]) && !(0, _queries.isListNested)(editor, list[1])) {
+              (0, _transforms.unwrapList)(newEditor, {
+                at: listItem[1]
+              });
+              var focusPoint = _slate.Editor.start(newEditor, listItem[1]);
+              (0, _core.focusEditor)(newEditor, focusPoint);
+              moved = true;
+              return;
+            }
+            var pointBeforeListItem = _slate.Editor.before(editor, editor.selection.focus);
+            var currentLic = null;
+            var hasMultipleChildren = false;
+            var editorOptions = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, editor), {}, {
+              selection: {
+                anchor: editor.selection.anchor,
+                focus: pointBeforeListItem
+              }
+            });
+            if (pointBeforeListItem && (0, _isAcrossListItems.isAcrossListItems)(editorOptions)) {
+              // get closest lic ancestor of current selectable
+              var _licNodes = (0, _core.getNodeEntries)(editor, {
+                at: listItem[1],
+                match: function match(node) {
+                  return node.type === _constants.PARAGRAPH;
+                },
+                mode: 'lowest'
+              });
+              currentLic = (0, _toConsumableArray2["default"])(_licNodes)[0];
+              hasMultipleChildren = currentLic[0].children.length > 1;
+            }
+            (0, _deleteMerge.deleteMerge)(editor, {
+              reverse: true,
+              unit: unit
+            });
+            moved = true;
+            if (!currentLic || !hasMultipleChildren) return;
+            var leftoverListItem = _slate.Editor.node(editor, {
+              at: _slate.Path.parent(currentLic[1])
+            });
+            if (leftoverListItem && leftoverListItem[0].children.length === 0) {
+              // remove the leftover empty list item
+              _slate.Transforms.removeNodes(editor, {
+                at: leftoverListItem[1]
+              });
+            }
+          });
+        }
+      }
+      return moved;
+    };
+    if (deleteBackwardList()) return;
+
+    // nothing todo
+    deleteBackward(unit);
+  };
+  newEditor.handleTab = function (event) {
+    if (!newEditor.selection) {
+      handleTab && handleTab();
+      return;
+    }
+    if ((0, _onTabHandle.onTabHandle)(newEditor, event)) return;
+    handleTab && handleTab();
+  };
+  newEditor.insertFragment = (0, _insertFragmentList.insertFragmentList)(newEditor);
+  newEditor.normalizeNode = (0, _normalizeList.normalizeList)(editor);
+  newEditor.insertText = function (text) {
+    var isPreventInsert = (0, _shortcut.handleShortcut)(newEditor, text);
+    if (isPreventInsert) return;
+    return insertText(text);
+  };
+  return newEditor;
+};
+var _default = exports["default"] = withList;

package/dist/extension/plugins/list/plugin/insert-break-list.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertBreakList = void 0;
+var _core = require("../../../core");
+var _queries = require("../queries");
+var _transforms = require("../transforms");
+var insertBreakList = exports.insertBreakList = function insertBreakList(editor) {
+  if (!editor.selection) return;
+
+  // moved | inserted
+  var moved = false;
+  var res = (0, _queries.getListItemEntry)(editor, {});
+
+  // if selection is in a li, and li content is empty
+  if (res) {
+    if ((0, _core.isBlockAboveEmpty)(editor)) {
+      moved = (0, _transforms.movedListItemUp)(editor, res);
+      if (moved) return true;
+    }
+  }
+  if (!moved) {
+    var inserted = (0, _transforms.insertListItem)(editor);
+    if (inserted) return true;
+  }
+  return;
+};