@seafile/sdoc-editor 1.0.53 → 1.0.55

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

@@ -1,46 +1,56 @@
-import { Editor, Text, Path, Span, Element, Node, Range } from '@seafile/slate';
-import { ReactEditor } from '@seafile/slate-react';
-import { match } from '../utils';
-import ObjectUtils from '../../../utils/object-utils';
-import { CODE_LINE } from '../../constants';
+"use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isTextNode = exports.isStartPoint = exports.isSelectionAtBlockStart = exports.isSelectionAtBlockEnd = exports.isRangeAcrossBlocks = exports.isMultiLevelList = exports.isLastNode = exports.isLastChild = exports.isHasImg = exports.isEndPoint = exports.isCurrentLineHasText = exports.isCurrentLineEmpty = exports.isBlockTextEmptyAfterSelection = exports.isBlockAboveEmpty = exports.isAncestorEmpty = exports.getTopLevelBlockNode = exports.getSelectedNodeEntryByType = exports.getSelectedNodeByTypes = exports.getSelectedNodeByType = exports.getSelectedElems = exports.getQueryOptions = exports.getPreviousPath = exports.getPrevNode = exports.getParentNode = exports.getNodes = exports.getNodeType = exports.getNodeEntries = exports.getNodeById = exports.getNode = exports.getNextSiblingNodes = exports.getNextNode = exports.getLastChildPath = exports.getLastChild = 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 _utils = require("../utils");
+var _objectUtils = _interopRequireDefault(require("../../../utils/object-utils"));
+var _constants = require("../../constants");
 // options
-export const getQueryOptions = (editor, options) => {
+const getQueryOptions = (editor, options) => {
   const {
     match: _match,
     block
   } = options;
   let newMatch = undefined;
   if (_match || block) {
-    newMatch = (n, path) => match(n, path, _match) && (!block || Editor.isBlock(editor, n));
+    newMatch = (n, path) => (0, _utils.match)(n, path, _match) && (!block || _slate.Editor.isBlock(editor, n));
   }
   return {
     ...options,
     match: newMatch
   };
 };
-export const findPath = (editor, node, defaultPath) => {
+exports.getQueryOptions = getQueryOptions;
+const findPath = (editor, node, defaultPath) => {
   try {
-    return ReactEditor.findPath(editor, node);
+    return _slateReact.ReactEditor.findPath(editor, node);
   } catch {
     return defaultPath;
   }
 };
 
 // get node
-export const getNode = (editor, path) => {
+exports.findPath = findPath;
+const getNode = (editor, path) => {
   let node = null;
   try {
-    node = Node.get(editor, path);
+    node = _slate.Node.get(editor, path);
   } catch (err) {
     node = null;
   }
   return node;
 };
-export const getNodeType = node => {
-  return Element.isElement(node) ? node.type : '';
+exports.getNode = getNode;
+const getNodeType = node => {
+  return _slate.Element.isElement(node) ? node.type : '';
 };
-export const getNodeById = (nodes, nodeId) => {
+exports.getNodeType = getNodeType;
+const getNodeById = (nodes, nodeId) => {
   let node;
   for (let i = 0; i < nodes.length; i++) {
     const currentNode = nodes[i];
@@ -64,11 +74,13 @@ export const getNodeById = (nodes, nodeId) => {
   }
   return node;
 };
-export const isTextNode = node => {
+exports.getNodeById = getNodeById;
+const isTextNode = node => {
   if (!node) return false;
-  if (!ObjectUtils.hasProperty(node, 'children') && ObjectUtils.hasProperty(node, 'text')) return true;
+  if (!_objectUtils.default.hasProperty(node, 'children') && _objectUtils.default.hasProperty(node, 'text')) return true;
 };
-export const getParentNode = (nodes, nodeId) => {
+exports.isTextNode = isTextNode;
+const getParentNode = (nodes, nodeId) => {
   let parentNode;
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
@@ -86,52 +98,60 @@ export const getParentNode = (nodes, nodeId) => {
   }
   return parentNode;
 };
-export const getNodes = (node, options) => {
-  return Node.nodes(node, options);
+exports.getParentNode = getParentNode;
+const getNodes = (node, options) => {
+  return _slate.Node.nodes(node, options);
 };
-export const getCommonNode = (root, path, ancestor) => {
-  return Node.common(root, path, ancestor);
+exports.getNodes = getNodes;
+const getCommonNode = (root, path, ancestor) => {
+  return _slate.Node.common(root, path, ancestor);
 };
-export const getSelectedNodeByType = (editor, type) => {
+exports.getCommonNode = getCommonNode;
+const getSelectedNodeByType = (editor, type) => {
   const match = n => getNodeType(n) === type;
-  const [nodeEntry] = Editor.nodes(editor, {
+  const [nodeEntry] = _slate.Editor.nodes(editor, {
     match,
     universal: true
   });
   return nodeEntry ? nodeEntry[0] : null;
 };
-export const getSelectedNodeByTypes = (editor, types) => {
+exports.getSelectedNodeByType = getSelectedNodeByType;
+const getSelectedNodeByTypes = (editor, types) => {
   const match = n => types.includes(getNodeType(n));
-  const [nodeEntry] = Editor.nodes(editor, {
+  const [nodeEntry] = _slate.Editor.nodes(editor, {
     match,
     universal: true
   });
   return nodeEntry ? nodeEntry[0] : null;
 };
-export const getSelectedNodeEntryByType = (editor, type) => {
+exports.getSelectedNodeByTypes = getSelectedNodeByTypes;
+const getSelectedNodeEntryByType = (editor, type) => {
   const match = n => getNodeType(n) === type;
-  const [nodeEntry] = Editor.nodes(editor, {
+  const [nodeEntry] = _slate.Editor.nodes(editor, {
     match,
     universal: false
   });
   return nodeEntry ? nodeEntry : null;
 };
-export const getNodeEntries = (editor, options) => {
-  return Editor.nodes(editor, getQueryOptions(editor, options));
+exports.getSelectedNodeEntryByType = getSelectedNodeEntryByType;
+const getNodeEntries = (editor, options) => {
+  return _slate.Editor.nodes(editor, getQueryOptions(editor, options));
 };
-export const getEditorString = (editor, at, options) => {
+exports.getNodeEntries = getNodeEntries;
+const getEditorString = (editor, at, options) => {
   if (!at) return '';
   try {
-    return Editor.string(editor, at, options);
+    return _slate.Editor.string(editor, at, options);
   } catch (error) {
     return '';
   }
 };
 
 // children & child
-export const getChildren = nodeEntry => {
+exports.getEditorString = getEditorString;
+const getChildren = nodeEntry => {
   const [node, path] = nodeEntry;
-  if (Element.isAncestor(node)) {
+  if (_slate.Element.isAncestor(node)) {
     const {
       children
     } = node;
@@ -142,20 +162,22 @@ export const getChildren = nodeEntry => {
   }
   return [];
 };
-export const getLastChild = nodeEntry => {
+exports.getChildren = getChildren;
+const getLastChild = nodeEntry => {
   const [node, path] = nodeEntry;
-  if (Text.isText(node)) return null;
+  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])];
 };
-export const getDeepInlineChildren = (editor, _ref) => {
+exports.getLastChild = getLastChild;
+const getDeepInlineChildren = (editor, _ref) => {
   let {
     children
   } = _ref;
   const inlineChildren = [];
   for (let child of children) {
-    if (Editor.isBlock(editor, child[0])) {
+    if (_slate.Editor.isBlock(editor, child[0])) {
       inlineChildren.push(...getDeepInlineChildren(editor, {
         children: getChildren(child)
       }));
@@ -165,35 +187,40 @@ export const getDeepInlineChildren = (editor, _ref) => {
   }
   return inlineChildren;
 };
-export const getLastChildPath = nodeEntry => {
+exports.getDeepInlineChildren = getDeepInlineChildren;
+const getLastChildPath = nodeEntry => {
   const lastChild = getLastChild(nodeEntry);
   if (!lastChild) return nodeEntry[1].concat([-1]);
   return lastChild[1];
 };
-export const getPreviousPath = path => {
+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);
 };
-export const isLastChild = (nodeEntry, childPath) => {
+exports.getPreviousPath = getPreviousPath;
+const isLastChild = (nodeEntry, childPath) => {
   const lastChildPath = getLastChildPath(nodeEntry);
-  return Path.equals(lastChildPath, childPath);
+  return _slate.Path.equals(lastChildPath, childPath);
 };
-export const getSelectedElems = editor => {
+exports.isLastChild = isLastChild;
+const getSelectedElems = editor => {
   const elems = [];
-  const nodeEntries = Editor.nodes(editor, {
+  const nodeEntries = _slate.Editor.nodes(editor, {
     universal: true
   });
   for (let nodeEntry of nodeEntries) {
     const [node] = nodeEntry;
-    if (Element.isElement(node)) elems.push(node);
+    if (_slate.Element.isElement(node)) elems.push(node);
   }
   return elems;
 };
 
 // siblings
-export const getNextSiblingNodes = (ancestorEntry, path) => {
+exports.getSelectedElems = getSelectedElems;
+const getNextSiblingNodes = (ancestorEntry, path) => {
   const [ancestor, ancestorPath] = ancestorEntry;
   const leafIndex = path[ancestorPath.length];
   const siblings = [];
@@ -207,46 +234,50 @@ export const getNextSiblingNodes = (ancestorEntry, path) => {
 };
 
 // parent
-export const getAboveNode = (editor, options) => {
-  return Editor.above(editor, getQueryOptions(editor, options));
+exports.getNextSiblingNodes = getNextSiblingNodes;
+const getAboveNode = (editor, options) => {
+  return _slate.Editor.above(editor, getQueryOptions(editor, options));
 };
-export const getAboveBlockNode = (editor, options) => {
+exports.getAboveNode = getAboveNode;
+const getAboveBlockNode = (editor, options) => {
   return getAboveNode(editor, {
     ...options,
     block: true
   });
 };
-export const getTopLevelBlockNode = editor => {
+exports.getAboveBlockNode = getAboveBlockNode;
+const getTopLevelBlockNode = editor => {
   return getAboveBlockNode(editor, {
-    match: (n, p) => Element.isElement(n) && p.length === 1
+    match: (n, p) => _slate.Element.isElement(n) && p.length === 1
   });
 };
-export const getPrevNode = editor => {
+exports.getTopLevelBlockNode = getTopLevelBlockNode;
+const getPrevNode = editor => {
   const lowerNodeEntry = getAboveNode(editor, {
     mode: 'lowest',
-    match: n => Element.isElement(n) && Editor.isBlock(editor, n)
+    match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
   });
   const highNodeEntry = getAboveNode(editor, {
     mode: 'highest',
-    match: n => Element.isElement(n) && Editor.isBlock(editor, n)
+    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 = Editor.previous(editor, {
+    prevNode = _slate.Editor.previous(editor, {
       at: lowerPath,
-      match: n => Element.isElement(n) && Editor.isBlock(editor, n)
+      match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
     });
   } catch (error) {
     prevNode = null;
   }
   if (lowerNode.id !== heightNode.id && !prevNode) {
     try {
-      prevNode = Editor.previous(editor, {
+      prevNode = _slate.Editor.previous(editor, {
         at: heightPath,
-        match: n => Element.isElement(n) && Editor.isBlock(editor, n)
+        match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
       });
     } catch (error) {
       prevNode = null;
@@ -254,38 +285,40 @@ export const getPrevNode = editor => {
   }
   return prevNode;
 };
-export const getCurrentNode = editor => {
+exports.getPrevNode = getPrevNode;
+const getCurrentNode = editor => {
   if (!editor.selection) return null;
-  const [nodeEntry] = Editor.nodes(editor, {
+  const [nodeEntry] = _slate.Editor.nodes(editor, {
     at: editor.selection,
-    match: n => Element.isElement(n) && Editor.isBlock(editor, n),
+    match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n),
     mode: 'lowest'
   });
   return nodeEntry || null;
 };
-export const getNextNode = editor => {
+exports.getCurrentNode = getCurrentNode;
+const getNextNode = editor => {
   const [lowerNode, lowerPath] = getAboveNode(editor, {
     mode: 'lowest',
-    match: n => Element.isElement(n) && Editor.isBlock(editor, n)
+    match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
   });
   const [heightNode, heightPath] = getAboveNode(editor, {
     mode: 'highest',
-    match: n => Element.isElement(n) && Editor.isBlock(editor, n)
+    match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
   });
   let nextNode = null;
   try {
-    nextNode = Editor.next(editor, {
+    nextNode = _slate.Editor.next(editor, {
       at: lowerPath,
-      match: n => Element.isElement(n) && Editor.isBlock(editor, n)
+      match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
     });
   } catch (error) {
     nextNode = null;
   }
   if (lowerNode.id !== heightNode.id && !nextNode) {
     try {
-      nextNode = Editor.next(editor, {
+      nextNode = _slate.Editor.next(editor, {
         at: heightPath,
-        match: n => Element.isElement(n) && Editor.isBlock(editor, n)
+        match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
       });
     } catch (error) {
       nextNode = null;
@@ -295,8 +328,9 @@ export const getNextNode = editor => {
 };
 
 // find node
-export const findNode = (editor, options) => {
-  const nodeEntries = Editor.nodes(editor, {
+exports.getNextNode = getNextNode;
+const findNode = (editor, options) => {
+  const nodeEntries = _slate.Editor.nodes(editor, {
     at: editor.selection || [],
     ...getQueryOptions(editor, options)
   });
@@ -306,7 +340,8 @@ export const findNode = (editor, options) => {
   }
   return undefined;
 };
-export const findDescendant = (editor, options) => {
+exports.findNode = findNode;
+const findDescendant = (editor, options) => {
   const {
     at = editor.selection,
     reverse = false,
@@ -316,29 +351,29 @@ export const findDescendant = (editor, options) => {
   if (!at) return;
   let from;
   let to;
-  if (Span.isSpan(at)) {
+  if (_slate.Span.isSpan(at)) {
     [from, to] = at;
-  } else if (Range.isRange(at)) {
-    const first = Editor.first(editor, at);
-    const last = Editor.last(editor, 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 (Path.isPath(at)) {
-    root = Editor.node(editor, at);
+  if (_slate.Path.isPath(at)) {
+    root = _slate.Editor.node(editor, at);
   }
-  const nodeEntries = Node.descendants(root[0], {
+  const nodeEntries = _slate.Node.descendants(root[0], {
     from,
     to,
     reverse,
     pass: _ref2 => {
       let [n] = _ref2;
-      return voids ? false : Editor.isVoid(editor, n);
+      return voids ? false : _slate.Editor.isVoid(editor, n);
     }
   });
   for (const [node, path] of nodeEntries) {
-    if (match(node, path, _match)) {
+    if ((0, _utils.match)(node, path, _match)) {
       return [node, at.concat(path)];
     }
   }
@@ -346,20 +381,23 @@ export const findDescendant = (editor, options) => {
 };
 
 // is
-export const isStartPoint = (editor, point, at) => {
-  return !!point && Editor.isStart(editor, point, at);
+exports.findDescendant = findDescendant;
+const isStartPoint = (editor, point, at) => {
+  return !!point && _slate.Editor.isStart(editor, point, at);
 };
-export const isEndPoint = (editor, point, at) => {
-  return !!point && Editor.isEnd(editor, point, at);
+exports.isStartPoint = isStartPoint;
+const isEndPoint = (editor, point, at) => {
+  return !!point && _slate.Editor.isEnd(editor, point, at);
 };
-export const isBlockTextEmptyAfterSelection = editor => {
+exports.isEndPoint = isEndPoint;
+const isBlockTextEmptyAfterSelection = editor => {
   if (!editor.selection) return false;
-  const blockAbove = Editor.above(editor, {
+  const blockAbove = _slate.Editor.above(editor, {
     block: true
   });
   if (!blockAbove) return false;
   const cursor = editor.selection.focus;
-  const selectionParentEntry = Editor.parent(editor, editor.selection);
+  const selectionParentEntry = _slate.Editor.parent(editor, editor.selection);
   if (!selectionParentEntry) return false;
   const [, selectionParentPath] = selectionParentEntry;
   if (!isEndPoint(editor, cursor, selectionParentPath)) return false;
@@ -367,7 +405,7 @@ export const isBlockTextEmptyAfterSelection = editor => {
   if (siblingNodes.length) {
     // 子节点包含 文本节点
     for (const siblingNode of siblingNodes) {
-      if (Text.isText(siblingNode) && siblingNode.text) {
+      if (_slate.Text.isText(siblingNode) && siblingNode.text) {
         return false;
       }
     }
@@ -376,14 +414,15 @@ export const isBlockTextEmptyAfterSelection = editor => {
   }
   return true;
 };
-export const isRangeAcrossBlocks = function (editor) {
+exports.isBlockTextEmptyAfterSelection = isBlockTextEmptyAfterSelection;
+const isRangeAcrossBlocks = function (editor) {
   let {
     at,
     ...options
   } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!at) at = editor.selection;
   if (!at) return;
-  const [start, end] = Range.edges(at);
+  const [start, end] = _slate.Range.edges(at);
   const startBlock = getAboveBlockNode(editor, {
     at: start,
     ...options
@@ -394,43 +433,49 @@ export const isRangeAcrossBlocks = function (editor) {
   });
   if (!startBlock && !endBlock) return;
   if (!startBlock || !endBlock) return true;
-  return !Path.equals(startBlock[1], endBlock[1]);
+  return !_slate.Path.equals(startBlock[1], endBlock[1]);
 };
-export const isAncestorEmpty = (editor, node) => {
-  return !Node.string(node) && !node.children.some(n => Editor.isInline(editor, n));
+exports.isRangeAcrossBlocks = isRangeAcrossBlocks;
+const isAncestorEmpty = (editor, node) => {
+  return !_slate.Node.string(node) && !node.children.some(n => _slate.Editor.isInline(editor, n));
 };
-export const isBlockAboveEmpty = editor => {
+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);
 };
-export const isSelectionAtBlockStart = (editor, options) => {
+exports.isBlockAboveEmpty = isBlockAboveEmpty;
+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) === CODE_LINE) {
+  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) || Range.isExpanded(editor.selection) && isStartPoint(editor, selection.anchor, path);
+  return isStartPoint(editor, selection.focus, path) || _slate.Range.isExpanded(editor.selection) && isStartPoint(editor, selection.anchor, path);
 };
-export const isSelectionAtBlockEnd = (editor, options) => {
+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);
 };
-export const isLastNode = (editor, node) => {
+exports.isSelectionAtBlockEnd = isSelectionAtBlockEnd;
+const isLastNode = (editor, node) => {
   const editorChildren = editor.children || [];
   const editorChildrenLength = editorChildren.length;
   return editorChildren[editorChildrenLength - 1] === node;
 };
-export const isHasImg = editor => {
+exports.isLastNode = isLastNode;
+const isHasImg = editor => {
   let hasImg = false;
-  for (const [node] of Editor.nodes(editor, {
+  for (const [node] of _slate.Editor.nodes(editor, {
     at: editor.selection
   })) {
     if ((node === null || node === void 0 ? void 0 : node.type) === 'image') {
@@ -439,24 +484,28 @@ export const isHasImg = editor => {
   }
   return hasImg;
 };
-export const isCurrentLineEmpty = editor => {
+exports.isHasImg = isHasImg;
+const isCurrentLineEmpty = editor => {
   const {
     selection
   } = editor;
-  if (!selection || !ReactEditor.isFocused(editor)) return false;
-  const [node] = Editor.node(editor, selection.focus.path.slice(0, -1));
-  if (Element.isElement(node)) {
-    return node.children.every(child => Element.isElement(child) ? false : Node.string(child) === '');
+  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;
 };
-export const isCurrentLineHasText = node => {
-  return Node.string(node).trim() !== '';
+exports.isCurrentLineEmpty = isCurrentLineEmpty;
+const isCurrentLineHasText = node => {
+  return _slate.Node.string(node).trim() !== '';
 };
-export const isMultiLevelList = listNode => {
+exports.isCurrentLineHasText = isCurrentLineHasText;
+const isMultiLevelList = listNode => {
   const {
     children
   } = listNode || {};
-  let isMultiLevel = (children === null || children === void 0 ? void 0 : children.find(item => (item === null || item === void 0 ? void 0 : item.children.length) > 1)) ? true : false;
+  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;

package/dist/basic-sdk/extension/core/transforms/focus-editor.js

@@ -1,11 +1,18 @@
-import { Editor, Transforms } from '@seafile/slate';
-import { ReactEditor } from '@seafile/slate-react';
-export const focusEditor = (editor, target) => {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.focusEditor = void 0;
+var _slate = require("@seafile/slate");
+var _slateReact = require("@seafile/slate-react");
+const focusEditor = (editor, target) => {
   if (target) {
-    Editor.withoutNormalizing(editor, () => {
-      Transforms.deselect(editor);
-      Transforms.select(editor, target);
+    _slate.Editor.withoutNormalizing(editor, () => {
+      _slate.Transforms.deselect(editor);
+      _slate.Transforms.select(editor, target);
     });
   }
-  ReactEditor.focus(editor);
-};
+  _slateReact.ReactEditor.focus(editor);
+};
+exports.focusEditor = focusEditor;

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

@@ -1,5 +1,60 @@
-export * from './move-children';
-export * from './remove-node-children';
-export * from './focus-editor';
-export * from './replace-node';
-export * from './update-parent-node.js';
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _moveChildren = require("./move-children");
+Object.keys(_moveChildren).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _moveChildren[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _moveChildren[key];
+    }
+  });
+});
+var _removeNodeChildren = require("./remove-node-children");
+Object.keys(_removeNodeChildren).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _removeNodeChildren[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _removeNodeChildren[key];
+    }
+  });
+});
+var _focusEditor = require("./focus-editor");
+Object.keys(_focusEditor).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _focusEditor[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _focusEditor[key];
+    }
+  });
+});
+var _replaceNode = require("./replace-node");
+Object.keys(_replaceNode).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _replaceNode[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _replaceNode[key];
+    }
+  });
+});
+var _updateParentNode = require("./update-parent-node.js");
+Object.keys(_updateParentNode).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _updateParentNode[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _updateParentNode[key];
+    }
+  });
+});