@block-kit/react 1.0.0

package/dist/lib/model/block.js

@@ -0,0 +1,168 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockModel = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const core_1 = require("@block-kit/core");
+const hooks_1 = require("@block-kit/utils/dist/es/hooks");
+const react_1 = __importStar(require("react"));
+const wrap_1 = require("../plugin/modules/wrap");
+const is_1 = require("../utils/is");
+const weak_map_1 = require("../utils/weak-map");
+const wrapper_1 = require("../utils/wrapper");
+const line_1 = require("./line");
+/**
+ * Block Model
+ * @param props
+ */
+const BlockView = props => {
+    const { editor, state } = props;
+    const flushing = (0, react_1.useRef)(false);
+    const [lines, setLines] = (0, react_1.useState)(() => state.getLines());
+    /**
+     * 设置行 DOM 节点
+     */
+    const setModel = (ref) => {
+        if (ref) {
+            editor.model.setBlockModel(ref, state);
+        }
+    };
+    /**
+     * 数据同步变更, 异步批量绘制变更
+     */
+    const onContentChange = (0, hooks_1.useMemoFn)(() => {
+        // 举个例子: 同步等待刷新的队列 => ||||||||
+        // 进入更新行为后, 异步行为等待, 同步的队列由于 !flushing 全部被守卫
+        // 主线程执行完毕后, 异步队列开始执行, 此时拿到的是最新数据, 以此批量重新渲染
+        if (flushing.current)
+            return void 0;
+        flushing.current = true;
+        Promise.resolve().then(() => {
+            flushing.current = false;
+            setLines(state.getLines());
+            editor.state.set(core_1.EDITOR_STATE.PAINTING, true);
+        });
+    });
+    /**
+     * 监听内容变更事件, 更新当前块视图
+     */
+    (0, react_1.useLayoutEffect)(() => {
+        editor.event.on(core_1.EDITOR_EVENT.CONTENT_CHANGE, onContentChange);
+        return () => {
+            editor.event.off(core_1.EDITOR_EVENT.CONTENT_CHANGE, onContentChange);
+        };
+    }, [editor.event, onContentChange]);
+    /**
+     * 视图更新需要重新设置选区 无依赖数组
+     */
+    (0, react_1.useLayoutEffect)(() => {
+        const selection = editor.selection.get();
+        if (!editor.state.get(core_1.EDITOR_STATE.COMPOSING) &&
+            editor.state.get(core_1.EDITOR_STATE.FOCUS) &&
+            selection) {
+            // 更新浏览器选区
+            editor.logger.debug("UpdateDOMSelection");
+            editor.selection.updateDOMSelection(true);
+        }
+    });
+    /**
+     * 视图更新需要触发视图绘制完成事件 无依赖数组
+     * state  -> parent -> node -> child ->|
+     * effect <- parent <- node <- child <-|
+     */
+    (0, react_1.useEffect)(() => {
+        editor.logger.debug("OnPaint");
+        editor.state.set(core_1.EDITOR_STATE.PAINTING, false);
+        Promise.resolve().then(() => {
+            editor.event.trigger(core_1.EDITOR_EVENT.PAINT, {});
+        });
+    });
+    /**
+     * 处理行节点
+     */
+    const elements = (0, react_1.useMemo)(() => {
+        return lines.map((line, index) => {
+            const node = ((0, jsx_runtime_1.jsx)(line_1.LineModel, { editor: editor, lineState: line, index: index }, line.key));
+            weak_map_1.JSX_TO_STATE.set(node, line);
+            return node;
+        });
+    }, [editor, lines]);
+    /**
+     * 将行包装组合 O(N)
+     */
+    const children = (0, react_1.useMemo)(() => {
+        const wrapped = [];
+        const keys = wrap_1.EDITOR_TO_WRAP_LINE_KEYS.get(editor);
+        const plugins = wrap_1.EDITOR_TO_WRAP_LINE_PLUGINS.get(editor);
+        if (!keys || !plugins)
+            return elements;
+        const len = elements.length;
+        for (let i = 0; i < len; ++i) {
+            const element = elements[i];
+            const symbol = (0, wrapper_1.getWrapSymbol)(keys, element);
+            const line = weak_map_1.JSX_TO_STATE.get(element);
+            if (!element || !line || !symbol) {
+                wrapped.push(element);
+                continue;
+            }
+            // 执行到此处说明需要包装相关节点(即使仅单个节点)
+            const nodes = [element];
+            for (let k = i + 1; k < len; ++k) {
+                const next = elements[k];
+                const nextSymbol = (0, wrapper_1.getWrapSymbol)(keys, next);
+                if (!next || !nextSymbol || nextSymbol !== symbol) {
+                    // 回退到上一个值, 以便下次循环时重新检查
+                    i = k - 1;
+                    break;
+                }
+                nodes.push(next);
+                i = k;
+            }
+            // 通过插件渲染包装节点
+            let wrapper = nodes;
+            const op = line.op;
+            for (const plugin of plugins) {
+                // 这里的状态以首个节点为准
+                const context = {
+                    lineState: line,
+                    children: wrapper,
+                };
+                if (plugin.match(line.op.attributes || {}, op) && plugin.wrapLine) {
+                    wrapper = plugin.wrapLine(context);
+                }
+            }
+            const key = `${i - nodes.length + 1}-${i}`;
+            wrapped.push((0, jsx_runtime_1.jsx)(react_1.default.Fragment, { children: wrapper }, key));
+        }
+        return wrapped;
+    }, [editor, elements]);
+    return ((0, jsx_runtime_1.jsxs)("div", { [core_1.BLOCK_KEY]: true, [core_1.BLOCK_ID_KEY]: state.key, ref: setModel, children: [props.placeholder && lines.length === 1 && (0, is_1.isStrictEmptyLine)(lines[0]) && ((0, jsx_runtime_1.jsx)("div", { [core_1.PLACEHOLDER_KEY]: true, style: {
+                    position: "absolute",
+                    opacity: "0.3",
+                    userSelect: "none",
+                    pointerEvents: "none",
+                }, children: props.placeholder })), children] }));
+};
+exports.BlockModel = react_1.default.memo(BlockView);

package/dist/lib/model/eol.d.ts

@@ -0,0 +1,6 @@
+import type { Editor, LeafState } from "@block-kit/core";
+import React from "react";
+export declare const EOLModel: React.NamedExoticComponent<{
+    editor: Editor;
+    leafState: LeafState;
+}>;

package/dist/lib/model/eol.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EOLModel = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const core_1 = require("@block-kit/core");
+const react_1 = __importDefault(require("react"));
+const zero_1 = require("../preset/zero");
+/**
+ * EOL Model
+ * @param props
+ */
+const EOLView = props => {
+    const { editor, leafState } = props;
+    const setModel = (ref) => {
+        if (ref) {
+            editor.model.setLeafModel(ref, leafState);
+        }
+    };
+    return ((0, jsx_runtime_1.jsx)("span", { [core_1.LEAF_KEY]: true, ref: setModel, children: (0, jsx_runtime_1.jsx)(zero_1.ZeroSpace, { enter: true }) }));
+};
+exports.EOLModel = react_1.default.memo(EOLView);

package/dist/lib/model/leaf.d.ts

@@ -0,0 +1,7 @@
+import type { Editor, LeafState } from "@block-kit/core";
+import React from "react";
+export declare const LeafModel: React.NamedExoticComponent<{
+    editor: Editor;
+    index: number;
+    leafState: LeafState;
+}>;

package/dist/lib/model/leaf.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeafModel = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const core_1 = require("@block-kit/core");
+const react_1 = __importStar(require("react"));
+const text_1 = require("../preset/text");
+const weak_map_1 = require("../utils/weak-map");
+/**
+ * Leaf Model
+ * @param props
+ */
+const LeafView = props => {
+    const { editor, leafState } = props;
+    const setModel = (ref) => {
+        if (ref) {
+            editor.model.setLeafModel(ref, leafState);
+        }
+    };
+    const runtime = (0, react_1.useMemo)(() => {
+        const text = leafState.getText();
+        const context = {
+            op: leafState.op,
+            classList: [],
+            lineState: leafState.parent,
+            leafState: leafState,
+            attributes: leafState.op.attributes,
+            style: {},
+            children: (0, jsx_runtime_1.jsx)(text_1.Text, { ref: el => weak_map_1.LEAF_TO_TEXT.set(leafState, el), children: text }),
+        };
+        const plugins = editor.plugin.getPriorityPlugins(core_1.PLUGIN_TYPE.RENDER_LEAF);
+        for (const plugin of plugins) {
+            if (plugin.match(context.attributes || {}, context.op)) {
+                context.children = plugin.renderLeaf(context);
+            }
+        }
+        return context;
+    }, [editor, leafState]);
+    return ((0, jsx_runtime_1.jsx)("span", { [core_1.LEAF_KEY]: true, ref: setModel, className: runtime.classList.join(" "), style: runtime.style, children: runtime.children }));
+};
+exports.LeafModel = react_1.default.memo(LeafView);

package/dist/lib/model/line.d.ts

@@ -0,0 +1,7 @@
+import type { Editor, LineState } from "@block-kit/core";
+import React from "react";
+export declare const LineModel: React.NamedExoticComponent<{
+    editor: Editor;
+    index: number;
+    lineState: LineState;
+}>;

package/dist/lib/model/line.js

@@ -0,0 +1,178 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineModel = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const core_1 = require("@block-kit/core");
+const delta_1 = require("@block-kit/delta");
+const utils_1 = require("@block-kit/utils");
+const hooks_1 = require("@block-kit/utils/dist/es/hooks");
+const react_1 = __importStar(require("react"));
+const wrap_1 = require("../plugin/modules/wrap");
+const weak_map_1 = require("../utils/weak-map");
+const wrapper_1 = require("../utils/wrapper");
+const eol_1 = require("./eol");
+const leaf_1 = require("./leaf");
+/**
+ * Line Model
+ * @param props
+ */
+const LineView = props => {
+    const { editor, lineState } = props;
+    /**
+     * 设置行 DOM 节点
+     */
+    const setModel = (ref) => {
+        if (ref) {
+            editor.model.setLineModel(ref, lineState);
+        }
+    };
+    /**
+     * 首次处理会将所有 DOM 渲染, 不需要执行脏数据检查
+     * 需要 LayoutEffect 以保证 DOM -> Sel 的执行顺序
+     */
+    (0, hooks_1.useUpdateLayoutEffect)(() => {
+        const leaves = lineState.getLeaves();
+        for (const leaf of leaves) {
+            const dom = weak_map_1.LEAF_TO_TEXT.get(leaf);
+            if (!dom)
+                continue;
+            const text = leaf.getText();
+            // 避免 React 非受控与 IME 造成的 DOM 内容问题
+            if (text === dom.textContent)
+                continue;
+            editor.logger.debug("Correct Text Node", dom);
+            const nodes = dom.childNodes;
+            for (let i = 1; i < nodes.length; ++i) {
+                const node = nodes[i];
+                node && node.remove();
+            }
+            if ((0, utils_1.isDOMText)(dom.firstChild)) {
+                dom.firstChild.nodeValue = text;
+            }
+        }
+    }, [lineState]);
+    /**
+     * 处理行内的节点
+     */
+    const elements = (0, react_1.useMemo)(() => {
+        const leaves = lineState.getLeaves();
+        const textLeaves = leaves.slice(0, -1);
+        const nodes = textLeaves.map((n, i) => {
+            const node = (0, jsx_runtime_1.jsx)(leaf_1.LeafModel, { editor: editor, index: i, leafState: n }, i);
+            weak_map_1.JSX_TO_STATE.set(node, n);
+            return node;
+        });
+        // 空行则仅存在一个 Leaf, 此时需要渲染空的占位节点
+        if (!nodes.length && leaves[0]) {
+            const leaf = leaves[0];
+            const node = (0, jsx_runtime_1.jsx)(eol_1.EOLModel, { editor: editor, leafState: leaf }, delta_1.EOL);
+            weak_map_1.JSX_TO_STATE.set(node, leaf);
+            nodes.push(node);
+            return nodes;
+        }
+        // inline-void(embed) 在行未时需要预设零宽字符来放置光标
+        const eolLeaf = leaves[leaves.length - 1];
+        const lastLeaf = textLeaves[textLeaves.length - 1];
+        if (lastLeaf && eolLeaf && lastLeaf.embed) {
+            const node = (0, jsx_runtime_1.jsx)(eol_1.EOLModel, { editor: editor, leafState: eolLeaf }, delta_1.EOL);
+            weak_map_1.JSX_TO_STATE.set(node, eolLeaf);
+            nodes.push(node);
+            return nodes;
+        }
+        return nodes;
+    }, [editor, lineState]);
+    /**
+     * 将行内节点包装组合 O(N)
+     */
+    const children = (0, react_1.useMemo)(() => {
+        const wrapped = [];
+        const keys = wrap_1.EDITOR_TO_WRAP_LEAF_KEYS.get(editor);
+        const plugins = wrap_1.EDITOR_TO_WRAP_LEAF_PLUGINS.get(editor);
+        if (!keys || !plugins)
+            return elements;
+        const len = elements.length;
+        for (let i = 0; i < len; ++i) {
+            const element = elements[i];
+            const symbol = (0, wrapper_1.getWrapSymbol)(keys, element);
+            const leaf = weak_map_1.JSX_TO_STATE.get(element);
+            if (!element || !leaf || !symbol) {
+                wrapped.push(element);
+                continue;
+            }
+            // 执行到此处说明需要包装相关节点(即使仅单个节点)
+            const nodes = [element];
+            for (let k = i + 1; k < len; ++k) {
+                const next = elements[k];
+                const nextSymbol = (0, wrapper_1.getWrapSymbol)(keys, next);
+                if (!next || !nextSymbol || nextSymbol !== symbol) {
+                    // 回退到上一个值, 以便下次循环时重新检查
+                    i = k - 1;
+                    break;
+                }
+                nodes.push(next);
+                i = k;
+            }
+            // 通过插件渲染包装节点
+            let wrapper = nodes;
+            const op = leaf.op;
+            for (const plugin of plugins) {
+                // 这里的状态以首个节点为准
+                const context = {
+                    leafState: leaf,
+                    children: wrapper,
+                };
+                if (plugin.match(leaf.op.attributes || {}, op) && plugin.wrapLeaf) {
+                    wrapper = plugin.wrapLeaf(context);
+                }
+            }
+            const key = `${i - nodes.length + 1}-${i}`;
+            wrapped.push((0, jsx_runtime_1.jsx)(react_1.default.Fragment, { children: wrapper }, key));
+        }
+        return wrapped;
+    }, [editor, elements]);
+    /**
+     * 处理行级节点的渲染
+     */
+    const runtime = (0, react_1.useMemo)(() => {
+        const context = {
+            classList: [],
+            lineState: lineState,
+            attributes: lineState.attributes,
+            style: {},
+            children,
+        };
+        const plugins = editor.plugin.getPriorityPlugins(core_1.PLUGIN_TYPE.RENDER_LINE);
+        for (const plugin of plugins) {
+            const op = Object.assign(Object.assign({}, delta_1.EOL_OP), { attributes: context.attributes });
+            if (plugin.match(context.attributes, op)) {
+                context.children = plugin.renderLine(context);
+            }
+        }
+        return context;
+    }, [children, editor.plugin, lineState]);
+    return ((0, jsx_runtime_1.jsx)("div", { [core_1.NODE_KEY]: true, ref: setModel, dir: "auto", className: (0, utils_1.cs)(runtime.classList), style: runtime.style, children: runtime.children }));
+};
+exports.LineModel = react_1.default.memo(LineView);

package/dist/lib/plugin/index.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="react" />
+import { CorePlugin } from "@block-kit/core";
+import type { ReactLeafContext, ReactLineContext, ReactWrapLeafContext, ReactWrapLineContext } from "./types";
+export declare abstract class EditorPlugin extends CorePlugin {
+    /**
+     * 渲染包装行节点
+     * - 调度优先级值越大 DOM 结构在越外层
+     */
+    wrapLine?(children: ReactWrapLineContext): React.ReactNode;
+    /**
+     * 渲染包装叶子节点
+     * - 调度优先级值越大 DOM 结构在越外层
+     */
+    wrapLeaf?(context: ReactWrapLeafContext): React.ReactNode;
+    /**
+     * 渲染行节点
+     * - 调度优先级值越大 DOM 结构在越外层
+     */
+    renderLine?(context: ReactLineContext): React.ReactNode;
+    /**
+     * 渲染块级子节点
+     * - 调度优先级值越大 DOM 结构在越外层
+     */
+    renderLeaf?(context: ReactLeafContext): React.ReactNode;
+}

package/dist/lib/plugin/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditorPlugin = void 0;
+const core_1 = require("@block-kit/core");
+class EditorPlugin extends core_1.CorePlugin {
+}
+exports.EditorPlugin = EditorPlugin;

package/dist/lib/plugin/modules/priority.d.ts

@@ -0,0 +1,13 @@
+import type { CorePlugin } from "@block-kit/core";
+/**
+ * 获取插件的优先级
+ * @param key
+ * @param plugin
+ */
+export declare const getPluginPriority: (key: string, plugin: CorePlugin) => number;
+/**
+ * 优先级定义装饰器
+ * - 兼容性实现, 非强制类型检查
+ * @param priority
+ */
+export declare function Priority<T>(priority: number): (target: T, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/lib/plugin/modules/priority.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Priority = exports.getPluginPriority = void 0;
+const core_1 = require("@block-kit/core");
+const utils_1 = require("@block-kit/utils");
+/**
+ * 获取插件的优先级
+ * @param key
+ * @param plugin
+ */
+const getPluginPriority = (key, plugin) => {
+    const priorityKey = `${core_1.PRIORITY_KEY}${key}`;
+    const priorityPlugin = plugin;
+    const priority = priorityPlugin[priorityKey];
+    return (0, utils_1.isNumber)(priority) ? priority : utils_1.DEFAULT_PRIORITY;
+};
+exports.getPluginPriority = getPluginPriority;
+/**
+ * 优先级定义装饰器
+ * - 兼容性实现, 非强制类型检查
+ * @param priority
+ */
+function Priority(priority) {
+    return function (target, key, descriptor) {
+        const priorityKey = `${core_1.PRIORITY_KEY}${key}`;
+        const plugin = target;
+        plugin[priorityKey] = priority;
+        return descriptor;
+    };
+}
+exports.Priority = Priority;

package/dist/lib/plugin/modules/wrap.d.ts

@@ -0,0 +1,26 @@
+import type { CorePlugin, Editor } from "@block-kit/core";
+import type { O, P } from "@block-kit/utils/dist/es/types";
+import type { EditorPlugin } from "../index";
+import { WRAP_TYPE } from "../types";
+export declare const EDITOR_TO_WRAP_LINE_KEYS: WeakMap<Editor, string[]>;
+export declare const EDITOR_TO_WRAP_LEAF_KEYS: WeakMap<Editor, string[]>;
+export declare const EDITOR_TO_WRAP_LINE_PLUGINS: WeakMap<Editor, EditorPlugin[]>;
+export declare const EDITOR_TO_WRAP_LEAF_PLUGINS: WeakMap<Editor, EditorPlugin[]>;
+/**
+ * 为 WrapNode 定义 Key
+ * @param ...keys
+ */
+export declare function InjectWrapKeys<T>(...keys: string[]): (target: T, key: O.Values<typeof WRAP_TYPE>, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * 获取插件的 WrapKeys
+ * @param key
+ * @param plugin
+ */
+export declare const getWrapKeys: (key: string, plugin: CorePlugin) => string[] | P.Undef;
+/**
+ * 初始化 Wrap 模式的插件
+ * - Wrap 模式的插件化在 React 层面渲染时实现
+ * - 其是渲染时调度且不存在 WrapState 的概念
+ * @param editor
+ */
+export declare const initWrapPlugins: (editor: Editor) => void;

package/dist/lib/plugin/modules/wrap.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initWrapPlugins = exports.getWrapKeys = exports.InjectWrapKeys = exports.EDITOR_TO_WRAP_LEAF_PLUGINS = exports.EDITOR_TO_WRAP_LINE_PLUGINS = exports.EDITOR_TO_WRAP_LEAF_KEYS = exports.EDITOR_TO_WRAP_LINE_KEYS = void 0;
+const types_1 = require("../types");
+const priority_1 = require("./priority");
+exports.EDITOR_TO_WRAP_LINE_KEYS = new WeakMap();
+exports.EDITOR_TO_WRAP_LEAF_KEYS = new WeakMap();
+exports.EDITOR_TO_WRAP_LINE_PLUGINS = new WeakMap();
+exports.EDITOR_TO_WRAP_LEAF_PLUGINS = new WeakMap();
+/**
+ * 为 WrapNode 定义 Key
+ * @param ...keys
+ */
+function InjectWrapKeys(...keys) {
+    return function (target, key, descriptor) {
+        const wrapPluginKey = `${key}Keys`;
+        const plugin = target;
+        plugin[wrapPluginKey] = keys;
+        return descriptor;
+    };
+}
+exports.InjectWrapKeys = InjectWrapKeys;
+/**
+ * 获取插件的 WrapKeys
+ * @param key
+ * @param plugin
+ */
+const getWrapKeys = (key, plugin) => {
+    const wrapPluginKey = `${key}Keys`;
+    const wrapPlugin = plugin;
+    const keys = wrapPlugin[wrapPluginKey];
+    return keys;
+};
+exports.getWrapKeys = getWrapKeys;
+/**
+ * 初始化 Wrap 模式的插件
+ * - Wrap 模式的插件化在 React 层面渲染时实现
+ * - 其是渲染时调度且不存在 WrapState 的概念
+ * @param editor
+ */
+const initWrapPlugins = (editor) => {
+    const plugins = editor.plugin.current;
+    const wrapLineKeys = [];
+    const wrapLeafKeys = [];
+    const wrapLinePlugins = [];
+    const wrapLeafPlugins = [];
+    for (const plugin of plugins) {
+        const lineKeys = (0, exports.getWrapKeys)(types_1.WRAP_TYPE.LINE, plugin);
+        if (lineKeys) {
+            wrapLineKeys.push(...lineKeys);
+        }
+        const leafKeys = (0, exports.getWrapKeys)(types_1.WRAP_TYPE.LEAF, plugin);
+        if (leafKeys) {
+            wrapLeafKeys.push(...leafKeys);
+        }
+        if (plugin.wrapLine) {
+            wrapLinePlugins.push(plugin);
+        }
+        if (plugin.wrapLeaf) {
+            wrapLeafPlugins.push(plugin);
+        }
+    }
+    wrapLinePlugins.sort((a, b) => {
+        const priorityA = (0, priority_1.getPluginPriority)(types_1.WRAP_TYPE.LINE, a);
+        const priorityB = (0, priority_1.getPluginPriority)(types_1.WRAP_TYPE.LINE, b);
+        return priorityA - priorityB;
+    });
+    wrapLeafPlugins.sort((a, b) => {
+        const priorityA = (0, priority_1.getPluginPriority)(types_1.WRAP_TYPE.LEAF, a);
+        const priorityB = (0, priority_1.getPluginPriority)(types_1.WRAP_TYPE.LEAF, b);
+        return priorityA - priorityB;
+    });
+    wrapLineKeys.length && exports.EDITOR_TO_WRAP_LINE_KEYS.set(editor, wrapLineKeys);
+    wrapLeafKeys.length && exports.EDITOR_TO_WRAP_LEAF_KEYS.set(editor, wrapLeafKeys);
+    wrapLinePlugins.length && exports.EDITOR_TO_WRAP_LINE_PLUGINS.set(editor, wrapLinePlugins);
+    wrapLeafPlugins.length && exports.EDITOR_TO_WRAP_LEAF_PLUGINS.set(editor, wrapLeafPlugins);
+};
+exports.initWrapPlugins = initWrapPlugins;