@ant-design/agentic-ui 2.7.1 → 2.9.0

package/dist/MarkdownEditor/editor/plugins/hotKeyCommands/tab.js

@@ -1,216 +1,338 @@
-// src/MarkdownEditor/editor/plugins/hotKeyCommands/tab.ts
-import {
-  Editor,
-  Element,
-  Node,
-  Path,
-  Point,
-  Range,
-  Text,
-  Transforms
-} from "slate";
-var TabKey = class {
-  constructor(editor) {
-    this.editor = editor;
-  }
-  run(e) {
-    var _a;
-    const sel = this.editor.selection;
-    if (!sel)
-      return;
-    e.preventDefault();
-    if (Range.isCollapsed(sel)) {
-      const [node] = Editor.nodes(this.editor, {
-        match: (n) => Element.isElement(n) && ["table-cell", "paragraph"].includes(n.type),
-        mode: "lowest"
-      });
-      if (sel && Editor.hasPath(this.editor, sel.anchor.path)) {
-        if (node) {
-          const [el, path] = node;
-          switch ((_a = node == null ? void 0 : node[0]) == null ? void 0 : _a.type) {
-            case "table-cell":
-              if (this.tableCell(el, path, e.shiftKey))
-                return;
-              break;
-            case "paragraph":
-              const parent = Editor.parent(this.editor, node[1]);
-              if (parent && parent[0].type === "list-item") {
-                if (this.listItem(node, e))
-                  return;
-              }
-              break;
-          }
-        }
-      }
-      if (e.shiftKey) {
-        const [leaf] = Editor.nodes(this.editor, {
-          match: (n) => Text.isText(n)
+/* eslint-disable no-case-declarations */ function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
         });
-        if (leaf) {
-          const str = Node.string(leaf[0]);
-          if (str && /^\t/.test(str)) {
-            Transforms.insertText(this.editor, "", {
-              at: {
-                anchor: { path: leaf[1], offset: 0 },
-                focus: { path: leaf[1], offset: 1 }
-              }
-            });
-            Transforms.select(this.editor, {
-              path: sel.anchor.path,
-              offset: sel.anchor.offset - 1
-            });
-          }
-        }
-      } else {
-        this.editor.insertText("	");
-      }
     } else {
-      const [start, end] = Range.edges(sel);
-      const [code] = Editor.nodes(this.editor, {
-        match: (n) => (n == null ? void 0 : n.type) === "code"
-      });
-      if (code) {
-        if (Point.compare(Editor.start(this.editor, code[1]), start) !== 1 && Point.compare(Editor.end(this.editor, code[1]), end) !== -1) {
-          return;
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
         }
-      } else if (e.shiftKey) {
-        const [node] = Editor.nodes(this.editor, {
-          match: (n) => n.type === "list"
-        });
-        if (node) {
-          const [start2, end2] = Range.edges(sel);
-          const anchor = start2.path.join(",").startsWith(node[1].join(",")) ? start2 : Editor.start(this.editor, node[1]);
-          const focus = end2.path.join(",").startsWith(node[1].join(",")) ? end2 : Editor.end(this.editor, node[1]);
-          Transforms.liftNodes(this.editor, { at: { anchor, focus } });
-          Transforms.liftNodes(this.editor);
-        } else {
-          Transforms.liftNodes(this.editor);
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
         }
-        return;
-      }
-      Transforms.select(this.editor, {
-        path: end.path,
-        offset: end.offset
-      });
     }
-  }
-  tableCell(node, nodePath, shift = false) {
-    const sel = this.editor.selection;
-    const text = Node.string(node);
-    if (shift) {
-      if (Path.hasPrevious(nodePath)) {
-        Transforms.select(
-          this.editor,
-          Editor.end(this.editor, Path.previous(nodePath))
-        );
-      } else if (Path.hasPrevious(Path.parent(nodePath))) {
-        Transforms.select(
-          this.editor,
-          Editor.end(this.editor, Path.previous(Path.parent(nodePath)))
-        );
-      }
-      return true;
-    } else {
-      if (text.length === sel.anchor.offset) {
-        if (Editor.hasPath(this.editor, Path.next(nodePath))) {
-          Transforms.select(
-            this.editor,
-            Editor.end(this.editor, Path.next(nodePath))
-          );
-        } else if (Editor.hasPath(this.editor, Path.next(Path.parent(nodePath)))) {
-          Transforms.select(
-            this.editor,
-            Editor.end(this.editor, [...Path.next(Path.parent(nodePath)), 0])
-          );
-        }
-        return true;
-      }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+import React from "react";
+import { Editor, Element, Node, Path, Point, Range, Text, Transforms } from "slate";
+/**
+ * TabKey 类用于处理编辑器中的 Tab 键事件。
+ */ export var TabKey = /*#__PURE__*/ function() {
+    "use strict";
+    function TabKey(editor) {
+        _class_call_check(this, TabKey);
+        _define_property(this, "editor", void 0);
+        this.editor = editor;
     }
-    return false;
-  }
-  listItem(node, e) {
-    var _a, _b, _c;
-    if (e.shiftKey) {
-      const li = (_a = Editor) == null ? void 0 : _a.node(this.editor, Path.parent(node[1]));
-      const ul = (_b = Editor) == null ? void 0 : _b.node(this.editor, Path.parent(li[1]));
-      const container = (_c = Editor) == null ? void 0 : _c.node(this.editor, Path.parent(ul[1]));
-      if (!Path.hasPrevious(ul[1]) && Node.parent(this.editor, ul[1]).type === "list-item")
-        return true;
-      const top = !Path.hasPrevious(node[1]);
-      const first = !Path.hasPrevious(li[1]);
-      if (top) {
-        Transforms.liftNodes(this.editor, { at: li[1] });
-        if (container[0].type === "list-item") {
-          const movePath = first ? ul[1] : Path.next(ul[1]);
-          Transforms.moveNodes(this.editor, {
-            at: movePath,
-            to: Path.next(container[1])
-          });
-          let start = li[0].children.length;
-          while (Editor.hasPath(this.editor, movePath)) {
-            Transforms.moveNodes(this.editor, {
-              at: movePath,
-              to: [...Path.next(container[1]), start]
-            });
-            start++;
-          }
-        } else {
-          Transforms.unwrapNodes(this.editor, {
-            at: first ? ul[1] : Path.next(ul[1])
-          });
-        }
-      } else {
-        const move = li[0].children.length - node[1].slice().pop() - 1;
-        Transforms.liftNodes(this.editor, {
-          at: {
-            anchor: Editor.start(this.editor, node[1]),
-            focus: Editor.end(this.editor, li[1])
-          }
-        });
-        const nextPath = Path.next(li[1]);
-        const lastIndex = nextPath.slice().pop();
-        Transforms.liftNodes(this.editor, {
-          at: {
-            anchor: { path: nextPath, offset: 1 },
-            focus: {
-              path: nextPath.slice(0, -1).concat([lastIndex + move]),
-              offset: 0
+    _create_class(TabKey, [
+        {
+            key: "run",
+            value: function run(e) {
+                var sel = this.editor.selection;
+                if (!sel) return;
+                e.preventDefault();
+                if (Range.isCollapsed(sel)) {
+                    var _Editor_nodes = _sliced_to_array(Editor.nodes(this.editor, {
+                        match: function(n) {
+                            return Element.isElement(n) && [
+                                'table-cell',
+                                'paragraph'
+                            ].includes(n.type);
+                        },
+                        mode: 'lowest'
+                    }), 1), node = _Editor_nodes[0];
+                    if (sel && Editor.hasPath(this.editor, sel.anchor.path)) {
+                        if (node) {
+                            var _node_;
+                            var _node = _sliced_to_array(node, 2), el = _node[0], path = _node[1];
+                            switch(node === null || node === void 0 ? void 0 : (_node_ = node[0]) === null || _node_ === void 0 ? void 0 : _node_.type){
+                                case 'table-cell':
+                                    if (this.tableCell(el, path, e.shiftKey)) return;
+                                    break;
+                                case 'paragraph':
+                                    var parent = Editor.parent(this.editor, node[1]);
+                                    if (parent && parent[0].type === 'list-item') {
+                                        if (this.listItem(node, e)) return;
+                                    }
+                                    break;
+                            }
+                        }
+                    }
+                    if (e.shiftKey) {
+                        var _Editor_nodes1 = _sliced_to_array(Editor.nodes(this.editor, {
+                            match: function(n) {
+                                return Text.isText(n);
+                            }
+                        }), 1), leaf = _Editor_nodes1[0];
+                        if (leaf) {
+                            var str = Node.string(leaf[0]);
+                            if (str && /^\t/.test(str)) {
+                                Transforms.insertText(this.editor, '', {
+                                    at: {
+                                        anchor: {
+                                            path: leaf[1],
+                                            offset: 0
+                                        },
+                                        focus: {
+                                            path: leaf[1],
+                                            offset: 1
+                                        }
+                                    }
+                                });
+                                Transforms.select(this.editor, {
+                                    path: sel.anchor.path,
+                                    offset: sel.anchor.offset - 1
+                                });
+                            }
+                        }
+                    } else {
+                        this.editor.insertText('\t');
+                    }
+                } else {
+                    var _Range_edges = _sliced_to_array(Range.edges(sel), 2), start = _Range_edges[0], end = _Range_edges[1];
+                    var _Editor_nodes2 = _sliced_to_array(Editor.nodes(this.editor, {
+                        match: function(n) {
+                            return (n === null || n === void 0 ? void 0 : n.type) === 'code';
+                        }
+                    }), 1), code = _Editor_nodes2[0];
+                    if (code) {
+                        if (Point.compare(Editor.start(this.editor, code[1]), start) !== 1 && Point.compare(Editor.end(this.editor, code[1]), end) !== -1) {
+                            return;
+                        }
+                    } else if (e.shiftKey) {
+                        var _Editor_nodes3 = _sliced_to_array(Editor.nodes(this.editor, {
+                            match: function(n) {
+                                return n.type === 'list';
+                            }
+                        }), 1), node1 = _Editor_nodes3[0];
+                        if (node1) {
+                            var _Range_edges1 = _sliced_to_array(Range.edges(sel), 2), start1 = _Range_edges1[0], end1 = _Range_edges1[1];
+                            var anchor = start1.path.join(',').startsWith(node1[1].join(',')) ? start1 : Editor.start(this.editor, node1[1]);
+                            var focus = end1.path.join(',').startsWith(node1[1].join(',')) ? end1 : Editor.end(this.editor, node1[1]);
+                            Transforms.liftNodes(this.editor, {
+                                at: {
+                                    anchor: anchor,
+                                    focus: focus
+                                }
+                            });
+                            Transforms.liftNodes(this.editor);
+                        } else {
+                            Transforms.liftNodes(this.editor);
+                        }
+                        return;
+                    }
+                    Transforms.select(this.editor, {
+                        path: end.path,
+                        offset: end.offset
+                    });
+                }
             }
-          }
-        });
-      }
-      return true;
-    } else {
-      const listItem = Editor.parent(this.editor, node[1]);
-      const list = Editor.parent(this.editor, listItem[1]);
-      if (!Node.string(node[0]) && Path.hasPrevious(listItem[1]) && listItem[0].children.length === 1) {
-        Transforms.removeNodes(this.editor, {
-          at: listItem[1]
-        });
-        const pre = Path.previous(listItem[1]);
-        const [next] = Node.children(this.editor, pre, { reverse: true });
-        Transforms.insertNodes(
-          this.editor,
-          {
-            type: "list",
-            order: list[0].order,
-            task: list[0].task,
-            children: [
-              {
-                type: "list-item",
-                checked: Node.get(this.editor, pre).checked,
-                children: [{ type: "paragraph", children: [{ text: "" }] }]
-              }
-            ]
-          },
-          { at: Path.next(next[1]), select: true }
-        );
-        return true;
-      }
-      return false;
-    }
-  }
-};
-export {
-  TabKey
-};
+        },
+        {
+            key: "tableCell",
+            value: function tableCell(node, nodePath) {
+                var shift = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+                var sel = this.editor.selection;
+                var text = Node.string(node);
+                if (shift) {
+                    if (Path.hasPrevious(nodePath)) {
+                        Transforms.select(this.editor, Editor.end(this.editor, Path.previous(nodePath)));
+                    } else if (Path.hasPrevious(Path.parent(nodePath))) {
+                        Transforms.select(this.editor, Editor.end(this.editor, Path.previous(Path.parent(nodePath))));
+                    }
+                    return true;
+                } else {
+                    if (text.length === sel.anchor.offset) {
+                        if (Editor.hasPath(this.editor, Path.next(nodePath))) {
+                            Transforms.select(this.editor, Editor.end(this.editor, Path.next(nodePath)));
+                        } else if (Editor.hasPath(this.editor, Path.next(Path.parent(nodePath)))) {
+                            Transforms.select(this.editor, Editor.end(this.editor, _to_consumable_array(Path.next(Path.parent(nodePath))).concat([
+                                0
+                            ])));
+                        }
+                        return true;
+                    }
+                }
+                return false;
+            }
+        },
+        {
+            key: "listItem",
+            value: function listItem(node, e) {
+                if (e.shiftKey) {
+                    var li = Editor === null || Editor === void 0 ? void 0 : Editor.node(this.editor, Path.parent(node[1]));
+                    var ul = Editor === null || Editor === void 0 ? void 0 : Editor.node(this.editor, Path.parent(li[1]));
+                    var container = Editor === null || Editor === void 0 ? void 0 : Editor.node(this.editor, Path.parent(ul[1]));
+                    if (!Path.hasPrevious(ul[1]) && Node.parent(this.editor, ul[1]).type === 'list-item') return true;
+                    var top = !Path.hasPrevious(node[1]);
+                    var first = !Path.hasPrevious(li[1]);
+                    if (top) {
+                        Transforms.liftNodes(this.editor, {
+                            at: li[1]
+                        });
+                        if (container[0].type === 'list-item') {
+                            var movePath = first ? ul[1] : Path.next(ul[1]);
+                            Transforms.moveNodes(this.editor, {
+                                at: movePath,
+                                to: Path.next(container[1])
+                            });
+                            var start = li[0].children.length;
+                            while(Editor.hasPath(this.editor, movePath)){
+                                Transforms.moveNodes(this.editor, {
+                                    at: movePath,
+                                    to: _to_consumable_array(Path.next(container[1])).concat([
+                                        start
+                                    ])
+                                });
+                                start++;
+                            }
+                        } else {
+                            Transforms.unwrapNodes(this.editor, {
+                                at: first ? ul[1] : Path.next(ul[1])
+                            });
+                        }
+                    } else {
+                        var move = li[0].children.length - node[1].slice().pop() - 1;
+                        Transforms.liftNodes(this.editor, {
+                            at: {
+                                anchor: Editor.start(this.editor, node[1]),
+                                focus: Editor.end(this.editor, li[1])
+                            }
+                        });
+                        var nextPath = Path.next(li[1]);
+                        var lastIndex = nextPath.slice().pop();
+                        Transforms.liftNodes(this.editor, {
+                            at: {
+                                anchor: {
+                                    path: nextPath,
+                                    offset: 1
+                                },
+                                focus: {
+                                    path: nextPath.slice(0, -1).concat([
+                                        lastIndex + move
+                                    ]),
+                                    offset: 0
+                                }
+                            }
+                        });
+                    }
+                    return true;
+                } else {
+                    var listItem = Editor.parent(this.editor, node[1]);
+                    var list = Editor.parent(this.editor, listItem[1]);
+                    if (!Node.string(node[0]) && Path.hasPrevious(listItem[1]) && listItem[0].children.length === 1) {
+                        Transforms.removeNodes(this.editor, {
+                            at: listItem[1]
+                        });
+                        var pre = Path.previous(listItem[1]);
+                        var _Node_children = _sliced_to_array(Node.children(this.editor, pre, {
+                            reverse: true
+                        }), 1), next = _Node_children[0];
+                        Transforms.insertNodes(this.editor, {
+                            type: 'list',
+                            order: list[0].order,
+                            task: list[0].task,
+                            children: [
+                                {
+                                    type: 'list-item',
+                                    checked: Node.get(this.editor, pre).checked,
+                                    children: [
+                                        {
+                                            type: 'paragraph',
+                                            children: [
+                                                {
+                                                    text: ''
+                                                }
+                                            ]
+                                        }
+                                    ]
+                                }
+                            ]
+                        }, {
+                            at: Path.next(next[1]),
+                            select: true
+                        });
+                        return true;
+                    }
+                    return false;
+                }
+            }
+        }
+    ]);
+    return TabKey;
+}();

package/dist/MarkdownEditor/editor/plugins/index.js

@@ -1,2 +1 @@
-// src/MarkdownEditor/editor/plugins/index.ts
 export * from "./withMarkdown";