@seafile/comment-editor 0.0.1-alpha.0

package/dist/basic-sdk/extension/core/queries/index.js

@@ -0,0 +1,613 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.someNode = exports.isTopLevelListItem = exports.isTextNode = exports.isStartPoint = exports.isSelectionAtBlockStart = exports.isSelectionAtBlockEnd = exports.isRangeInSameBlock = exports.isRangeAcrossBlocks = exports.isMultiLevelList = exports.isMiddlePoint = exports.isLastNode = exports.isLastChild = exports.isHasImg = exports.isFirstChild = exports.isEndPoint = exports.isEmptyArticle = exports.isCursorAtBlockStart = exports.isCurrentLineHasText = exports.isCurrentLineEmpty = exports.isContainsVoidElement = exports.isBlockTextEmptyAfterSelection = exports.isBlockAboveEmpty = exports.isAncestorEmpty = exports.getTopLevelBlockNode = exports.getStartPoint = exports.getSelectedNodeEntryByType = exports.getSelectedNodeByTypes = exports.getSelectedNodeByType = exports.getSelectedElems = exports.getQueryOptions = exports.getPreviousPath = exports.getPrevNode = exports.getPointBefore = exports.getParentNode = exports.getNodes = exports.getNodeType = exports.getNodeEntries = exports.getNodeById = exports.getNode = exports.getNextSiblingNodes = exports.getNextNode = exports.getLastChildPath = exports.getLastChild = exports.getEndPoint = exports.getEditorString = exports.getDeepInlineChildren = exports.getCurrentNode = exports.getCommonNode = exports.getChildren = exports.getAboveNode = exports.getAboveBlockNode = exports.findPath = exports.findNode = exports.findDescendant = void 0;
+var _slate = require("@seafile/slate");
+var _slateReact = require("@seafile/slate-react");
+var _constants = require("../../constants");
+var _utils = require("../utils");
+// options
+const getQueryOptions = (editor, options) => {
+  const {
+    match: _match,
+    block
+  } = options;
+  let newMatch = undefined;
+  if (_match || block) {
+    newMatch = (n, path) => (0, _utils.match)(n, path, _match) && (!block || _slate.Editor.isBlock(editor, n));
+  }
+  return {
+    ...options,
+    match: newMatch
+  };
+};
+exports.getQueryOptions = getQueryOptions;
+const findPath = (editor, node, defaultPath) => {
+  try {
+    return _slateReact.ReactEditor.findPath(editor, node);
+  } catch {
+    return defaultPath;
+  }
+};
+
+// get node
+exports.findPath = findPath;
+const getNode = (editor, path) => {
+  let node = null;
+  try {
+    node = _slate.Node.get(editor, path);
+  } catch (err) {
+    node = null;
+  }
+  return node;
+};
+exports.getNode = getNode;
+const getNodeType = node => {
+  return _slate.Element.isElement(node) ? node.type : '';
+};
+exports.getNodeType = getNodeType;
+const getNodeById = (nodes, nodeId) => {
+  let node;
+  for (let i = 0; i < nodes.length; i++) {
+    const currentNode = nodes[i];
+    if (currentNode.id === nodeId) {
+      node = currentNode;
+      break;
+    }
+    const {
+      children: childrenNodes
+    } = currentNode;
+    if (!Array.isArray(childrenNodes)) continue;
+    let childNode = childrenNodes.find(node => node.id === nodeId);
+    if (childNode) {
+      node = childNode;
+      break;
+    }
+    childNode = getNodeById(childrenNodes, nodeId);
+    if (!childNode) continue;
+    node = childNode;
+    break;
+  }
+  return node;
+};
+exports.getNodeById = getNodeById;
+const getParentNode = (nodes, nodeId) => {
+  let parentNode;
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const {
+      children: childrenNodes
+    } = node;
+    if (!Array.isArray(childrenNodes)) continue;
+    if (childrenNodes.find(node => node.id === nodeId)) {
+      parentNode = node;
+    } else {
+      parentNode = getParentNode(childrenNodes, nodeId);
+    }
+    if (!parentNode) continue;
+    break;
+  }
+  return parentNode;
+};
+exports.getParentNode = getParentNode;
+const getNodes = (node, options) => {
+  return _slate.Node.nodes(node, options);
+};
+exports.getNodes = getNodes;
+const getCommonNode = (root, path, ancestor) => {
+  return _slate.Node.common(root, path, ancestor);
+};
+exports.getCommonNode = getCommonNode;
+const getSelectedNodeByType = (editor, type) => {
+  const match = n => getNodeType(n) === type;
+  if (!editor.selection) return;
+  const at = _slate.Range.isCollapsed(editor.selection) ? editor.selection : _slate.Editor.start(editor, editor.selection);
+  const [nodeEntry] = _slate.Editor.nodes(editor, {
+    match,
+    universal: true,
+    at
+  });
+  return nodeEntry ? nodeEntry[0] : null;
+};
+exports.getSelectedNodeByType = getSelectedNodeByType;
+const getSelectedNodeByTypes = (editor, types) => {
+  const match = n => types.includes(getNodeType(n));
+  const [nodeEntry] = _slate.Editor.nodes(editor, {
+    match,
+    universal: true
+  });
+  return nodeEntry ? nodeEntry[0] : null;
+};
+exports.getSelectedNodeByTypes = getSelectedNodeByTypes;
+const getSelectedNodeEntryByType = (editor, type) => {
+  const match = n => getNodeType(n) === type;
+  const [nodeEntry] = _slate.Editor.nodes(editor, {
+    match,
+    universal: false
+  });
+  return nodeEntry ? nodeEntry : null;
+};
+exports.getSelectedNodeEntryByType = getSelectedNodeEntryByType;
+const getNodeEntries = (editor, options) => {
+  return _slate.Editor.nodes(editor, getQueryOptions(editor, options));
+};
+exports.getNodeEntries = getNodeEntries;
+const getEditorString = (editor, at, options) => {
+  if (!at) return '';
+  try {
+    return _slate.Editor.string(editor, at, options);
+  } catch (error) {
+    return '';
+  }
+};
+
+// children & child
+exports.getEditorString = getEditorString;
+const getChildren = nodeEntry => {
+  const [node, path] = nodeEntry;
+  if (_slate.Element.isAncestor(node)) {
+    const {
+      children
+    } = node;
+    return children.map((child, index) => {
+      const childPath = path.concat([index]);
+      return [child, childPath];
+    });
+  }
+  return [];
+};
+exports.getChildren = getChildren;
+const getLastChild = nodeEntry => {
+  const [node, path] = nodeEntry;
+  if (_slate.Text.isText(node)) return null;
+  if (!node.children.length) return null;
+  const children = node.children;
+  return [children[children.length - 1], path.concat([children.length - 1])];
+};
+exports.getLastChild = getLastChild;
+const getDeepInlineChildren = (editor, _ref) => {
+  let {
+    children
+  } = _ref;
+  const inlineChildren = [];
+  for (let child of children) {
+    if (_slate.Editor.isBlock(editor, child[0])) {
+      inlineChildren.push(...getDeepInlineChildren(editor, {
+        children: getChildren(child)
+      }));
+    } else {
+      inlineChildren.push(child);
+    }
+  }
+  return inlineChildren;
+};
+exports.getDeepInlineChildren = getDeepInlineChildren;
+const getLastChildPath = nodeEntry => {
+  const lastChild = getLastChild(nodeEntry);
+  if (!lastChild) return nodeEntry[1].concat([-1]);
+  return lastChild[1];
+};
+exports.getLastChildPath = getLastChildPath;
+const getPreviousPath = path => {
+  if (path.length === 0) return;
+  const last = path[path.length - 1];
+  if (last <= 0) return;
+  return path.slice(0, -1).concat(last - 1);
+};
+exports.getPreviousPath = getPreviousPath;
+const getSelectedElems = editor => {
+  const elems = [];
+  const nodeEntries = _slate.Editor.nodes(editor, {
+    universal: true
+  });
+  for (let nodeEntry of nodeEntries) {
+    const [node] = nodeEntry;
+    if (_slate.Element.isElement(node)) elems.push(node);
+  }
+  return elems;
+};
+
+// siblings
+exports.getSelectedElems = getSelectedElems;
+const getNextSiblingNodes = (ancestorEntry, path) => {
+  const [ancestor, ancestorPath] = ancestorEntry;
+  const leafIndex = path[ancestorPath.length];
+  const siblings = [];
+  const ancestorChildren = ancestor.children;
+  if (leafIndex + 1 < ancestor.children.length) {
+    for (let i = leafIndex + 1; i < ancestor.children.length; i++) {
+      siblings.push(ancestorChildren[i]);
+    }
+  }
+  return siblings;
+};
+
+// parent
+exports.getNextSiblingNodes = getNextSiblingNodes;
+const getAboveNode = (editor, options) => {
+  return _slate.Editor.above(editor, getQueryOptions(editor, options));
+};
+exports.getAboveNode = getAboveNode;
+const getAboveBlockNode = (editor, options) => {
+  return getAboveNode(editor, {
+    ...options,
+    block: true
+  });
+};
+exports.getAboveBlockNode = getAboveBlockNode;
+const getTopLevelBlockNode = editor => {
+  return getAboveBlockNode(editor, {
+    match: (n, p) => _slate.Element.isElement(n) && p.length === 1
+  });
+};
+exports.getTopLevelBlockNode = getTopLevelBlockNode;
+const getPrevNode = editor => {
+  const lowerNodeEntry = getAboveNode(editor, {
+    mode: 'lowest',
+    match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
+  });
+  const highNodeEntry = getAboveNode(editor, {
+    mode: 'highest',
+    match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
+  });
+  if (!lowerNodeEntry || !highNodeEntry) return null;
+  const [heightNode, heightPath] = highNodeEntry;
+  const [lowerNode, lowerPath] = lowerNodeEntry;
+  let prevNode = null;
+  try {
+    prevNode = _slate.Editor.previous(editor, {
+      at: lowerPath,
+      match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
+    });
+  } catch (error) {
+    prevNode = null;
+  }
+  if (lowerNode.id !== heightNode.id && !prevNode) {
+    try {
+      prevNode = _slate.Editor.previous(editor, {
+        at: heightPath,
+        match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
+      });
+    } catch (error) {
+      prevNode = null;
+    }
+  }
+  return prevNode;
+};
+exports.getPrevNode = getPrevNode;
+const getCurrentNode = editor => {
+  if (!editor.selection) return null;
+  const [nodeEntry] = _slate.Editor.nodes(editor, {
+    at: editor.selection,
+    match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n),
+    mode: 'lowest'
+  });
+  return nodeEntry || null;
+};
+exports.getCurrentNode = getCurrentNode;
+const getNextNode = editor => {
+  const [lowerNode, lowerPath] = getAboveNode(editor, {
+    mode: 'lowest',
+    match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
+  });
+  const [heightNode, heightPath] = getAboveNode(editor, {
+    mode: 'highest',
+    match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
+  });
+  let nextNode = null;
+  try {
+    nextNode = _slate.Editor.next(editor, {
+      at: lowerPath,
+      match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
+    });
+  } catch (error) {
+    nextNode = null;
+  }
+  if (lowerNode.id !== heightNode.id && !nextNode) {
+    try {
+      nextNode = _slate.Editor.next(editor, {
+        at: heightPath,
+        match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
+      });
+    } catch (error) {
+      nextNode = null;
+    }
+  }
+  return nextNode;
+};
+
+// find node
+exports.getNextNode = getNextNode;
+const findNode = (editor, options) => {
+  const nodeEntries = _slate.Editor.nodes(editor, {
+    at: editor.selection || [],
+    ...getQueryOptions(editor, options)
+  });
+  const _nodeEntries = Array.from(nodeEntries);
+  if (_nodeEntries[0]) {
+    return _nodeEntries[0];
+  }
+  return undefined;
+};
+exports.findNode = findNode;
+const findDescendant = (editor, options) => {
+  const {
+    at = editor.selection,
+    reverse = false,
+    voids = false,
+    match: _match
+  } = options;
+  if (!at) return;
+  let from;
+  let to;
+  if (_slate.Span.isSpan(at)) {
+    [from, to] = at;
+  } else if (_slate.Range.isRange(at)) {
+    const first = _slate.Editor.first(editor, at);
+    const last = _slate.Editor.last(editor, at);
+    from = reverse ? last : first;
+    to = reverse ? first : last;
+  }
+  let root = [editor, []];
+  if (_slate.Path.isPath(at)) {
+    root = _slate.Editor.node(editor, at);
+  }
+  const nodeEntries = _slate.Node.descendants(root[0], {
+    from,
+    to,
+    reverse,
+    pass: _ref2 => {
+      let [n] = _ref2;
+      return voids ? false : _slate.Editor.isVoid(editor, n);
+    }
+  });
+  for (const [node, path] of nodeEntries) {
+    if ((0, _utils.match)(node, path, _match)) {
+      return [node, at.concat(path)];
+    }
+  }
+  return undefined;
+};
+
+// is
+exports.findDescendant = findDescendant;
+const isTextNode = node => {
+  if (!node) return false;
+  if (_slate.Text.isText(node)) return true;
+  return false;
+};
+exports.isTextNode = isTextNode;
+const isLastChild = (nodeEntry, childPath) => {
+  const lastChildPath = getLastChildPath(nodeEntry);
+  return _slate.Path.equals(lastChildPath, childPath);
+};
+exports.isLastChild = isLastChild;
+const isStartPoint = (editor, point, at) => {
+  return !!point && _slate.Editor.isStart(editor, point, at);
+};
+exports.isStartPoint = isStartPoint;
+const isEndPoint = (editor, point, at) => {
+  return !!point && _slate.Editor.isEnd(editor, point, at);
+};
+exports.isEndPoint = isEndPoint;
+const isMiddlePoint = (editor, point, at) => {
+  return !isStartPoint(editor, point, at) && !isEndPoint(editor, point, at);
+};
+exports.isMiddlePoint = isMiddlePoint;
+const isBlockTextEmptyAfterSelection = editor => {
+  if (!editor.selection) return false;
+  const blockAbove = _slate.Editor.above(editor, {
+    block: true
+  });
+  if (!blockAbove) return false;
+  const cursor = editor.selection.focus;
+  const selectionParentEntry = _slate.Editor.parent(editor, editor.selection);
+  if (!selectionParentEntry) return false;
+  const [, selectionParentPath] = selectionParentEntry;
+  if (!isEndPoint(editor, cursor, selectionParentPath)) return false;
+  const siblingNodes = getNextSiblingNodes(blockAbove, cursor.path);
+  if (siblingNodes.length) {
+    // 子节点包含 文本节点
+    for (const siblingNode of siblingNodes) {
+      if (_slate.Text.isText(siblingNode) && siblingNode.text) {
+        return false;
+      }
+    }
+  } else {
+    return isEndPoint(editor, cursor, blockAbove[1]);
+  }
+  return true;
+};
+exports.isBlockTextEmptyAfterSelection = isBlockTextEmptyAfterSelection;
+const isRangeAcrossBlocks = function (editor) {
+  let {
+    at,
+    ...options
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  try {
+    if (!at) at = editor.selection;
+    if (!at) return;
+    const [start, end] = _slate.Range.edges(at);
+    const startBlock = getAboveBlockNode(editor, {
+      at: start,
+      ...options
+    });
+    const endBlock = getAboveBlockNode(editor, {
+      at: end,
+      ...options
+    });
+    if (!startBlock && !endBlock) return;
+    if (!startBlock || !endBlock) return true;
+    return !_slate.Path.equals(startBlock[1], endBlock[1]);
+  } catch (error) {
+    return true;
+  }
+};
+exports.isRangeAcrossBlocks = isRangeAcrossBlocks;
+const isAncestorEmpty = (editor, node) => {
+  return !_slate.Node.string(node) && !node.children.some(n => _slate.Editor.isInline(editor, n));
+};
+exports.isAncestorEmpty = isAncestorEmpty;
+const isBlockAboveEmpty = editor => {
+  var _getAboveBlockNode;
+  const block = (_getAboveBlockNode = getAboveBlockNode(editor)) === null || _getAboveBlockNode === void 0 ? void 0 : _getAboveBlockNode[0];
+  if (!block) return false;
+  return isAncestorEmpty(editor, block);
+};
+exports.isBlockAboveEmpty = isBlockAboveEmpty;
+const isCursorAtBlockStart = (editor, options) => {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const nodeEntry = getAboveBlockNode(editor, options);
+  let [node, path] = nodeEntry || [];
+  if (!path) return false;
+
+  // Special handling of placeholders, such as link, inline image
+  if (_slate.Node.string(node.children[0]).length === 0) {
+    const {
+      offset,
+      path: point
+    } = selection.focus;
+    if (offset !== 0) return false;
+    return _slate.Path.equals(point, [path[0], 1, 0]);
+  }
+  return isStartPoint(editor, selection.focus, path);
+};
+exports.isCursorAtBlockStart = isCursorAtBlockStart;
+const isSelectionAtBlockStart = (editor, options) => {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const nodeEntry = getAboveBlockNode(editor, options);
+  let path = nodeEntry === null || nodeEntry === void 0 ? void 0 : nodeEntry[1];
+  if ((nodeEntry === null || nodeEntry === void 0 ? void 0 : nodeEntry[0].type) === _constants.CODE_LINE) {
+    path = [path[0]];
+  }
+  if (!path) return false;
+  return isStartPoint(editor, selection.focus, path) || _slate.Range.isExpanded(editor.selection) && isStartPoint(editor, selection.anchor, path);
+};
+exports.isSelectionAtBlockStart = isSelectionAtBlockStart;
+const isSelectionAtBlockEnd = (editor, options) => {
+  var _getAboveBlockNode2, _editor$selection;
+  const path = (_getAboveBlockNode2 = getAboveBlockNode(editor, options)) === null || _getAboveBlockNode2 === void 0 ? void 0 : _getAboveBlockNode2[1];
+  return !!path && isEndPoint(editor, (_editor$selection = editor.selection) === null || _editor$selection === void 0 ? void 0 : _editor$selection.focus, path);
+};
+exports.isSelectionAtBlockEnd = isSelectionAtBlockEnd;
+const isLastNode = (editor, node) => {
+  const editorChildren = editor.children || [];
+  const editorChildrenLength = editorChildren.length;
+  return editorChildren[editorChildrenLength - 1] === node;
+};
+exports.isLastNode = isLastNode;
+const isHasImg = editor => {
+  let hasImg = false;
+  for (const [node] of _slate.Editor.nodes(editor, {
+    at: editor.selection
+  })) {
+    if ((node === null || node === void 0 ? void 0 : node.type) === 'image') {
+      hasImg = true;
+    }
+  }
+  return hasImg;
+};
+exports.isHasImg = isHasImg;
+const isCurrentLineEmpty = editor => {
+  const {
+    selection
+  } = editor;
+  if (!selection || !_slateReact.ReactEditor.isFocused(editor)) return false;
+  const [node] = _slate.Editor.node(editor, selection.focus.path.slice(0, -1));
+  if (_slate.Element.isElement(node)) {
+    return node.children.every(child => _slate.Element.isElement(child) ? false : _slate.Node.string(child) === '');
+  }
+  return true;
+};
+exports.isCurrentLineEmpty = isCurrentLineEmpty;
+const isCurrentLineHasText = node => {
+  return _slate.Node.string(node).trim() !== '';
+};
+exports.isCurrentLineHasText = isCurrentLineHasText;
+const isMultiLevelList = listNode => {
+  const {
+    children
+  } = listNode || {};
+  let isMultiLevel = children !== null && children !== void 0 && children.find(item => (item === null || item === void 0 ? void 0 : item.children.length) > 1) ? true : false;
+  return isMultiLevel;
+};
+exports.isMultiLevelList = isMultiLevelList;
+const isTopLevelListItem = editor => {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const [, paragraphPath] = _slate.Editor.parent(editor, selection) || [];
+  if (paragraphPath.length !== 0) {
+    const [listItemNode, listItemPath] = _slate.Editor.parent(editor, paragraphPath) || [];
+    return listItemNode && listItemPath && (listItemNode === null || listItemNode === void 0 ? void 0 : listItemNode.type) === _constants.LIST_ITEM && (listItemPath === null || listItemPath === void 0 ? void 0 : listItemPath.length) === 2;
+  }
+  return false;
+};
+exports.isTopLevelListItem = isTopLevelListItem;
+const isRangeInSameBlock = function (editor) {
+  let {
+    at,
+    ...options
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  if (!at) at = editor.selection;
+  if (!at) return;
+  const [start, end] = _slate.Range.edges(at);
+  const startBlock = getAboveNode(editor, {
+    at: start,
+    ...options
+  });
+  const endBlock = getAboveNode(editor, {
+    at: end,
+    ...options
+  });
+  if (!startBlock || !endBlock) return;
+  return _slate.Path.equals(startBlock[1], endBlock[1]);
+};
+exports.isRangeInSameBlock = isRangeInSameBlock;
+const isFirstChild = path => {
+  return path.at(-1) === 0;
+};
+exports.isFirstChild = isFirstChild;
+const isEmptyArticle = editor => {
+  if (editor.children.length === 0) {
+    return true;
+  }
+  return false;
+};
+exports.isEmptyArticle = isEmptyArticle;
+const isContainsVoidElement = root => {
+  const nodes = _slate.Node.nodes(root);
+  for (const nodeEntry of nodes) {
+    const [n] = nodeEntry;
+    if ((n === null || n === void 0 ? void 0 : n.type) === _constants.IMAGE) {
+      return true;
+    }
+  }
+  return false;
+};
+exports.isContainsVoidElement = isContainsVoidElement;
+const getStartPoint = (editor, at) => {
+  return _slate.Editor.start(editor, at);
+};
+exports.getStartPoint = getStartPoint;
+const getEndPoint = (editor, at) => {
+  return _slate.Editor.end(editor, at);
+};
+exports.getEndPoint = getEndPoint;
+const getPointBefore = (editor, at) => {
+  return _slate.Editor.before(editor, at);
+};
+exports.getPointBefore = getPointBefore;
+const someNode = (editor, options) => {
+  return !!findNode(editor, options);
+};
+exports.someNode = someNode;