@visactor/vrender-core 0.21.7 → 0.22.0-vstory.1

package/es/plugins/builtin-plugin/richtext-edit-plugin.js

@@ -1,38 +1,55 @@
-import { isObject, isString, merge } from "@visactor/vutils";
+import { isObject, merge } from "@visactor/vutils";
 
 import { Generator } from "../../common/generator";
 
-import { createGroup, createLine, createRect } from "../../graphic";
+import { createGroup, createLine, createRect, RichText } from "../../graphic";
 
-import { EditModule, findCursorIndexIgnoreLinebreak } from "./edit-module";
+import { DefaultTicker, DefaultTimeline } from "../../animate";
+
+import { EditModule, findConfigIndexByCursorIdx } from "./edit-module";
+
+import { application } from "../../application";
+
+import { getWordStartEndIdx } from "../../graphic/richtext/utils";
 
 class Selection {
-    constructor(cacheSelectionStartCursorIdx, cacheCurCursorIdx, selectionStartCursorIdx, curCursorIdx, rt) {
+    constructor(selectionStartCursorIdx, curCursorIdx, rt) {
         this.curCursorIdx = curCursorIdx, this.selectionStartCursorIdx = selectionStartCursorIdx, 
-        this.cacheCurCursorIdx = cacheCurCursorIdx, this.cacheSelectionStartCursorIdx = cacheSelectionStartCursorIdx, 
         this.rt = rt;
     }
+    isEmpty() {
+        return this.selectionStartCursorIdx === this.curCursorIdx;
+    }
+    getSelectionPureText() {
+        const minCursorIdx = Math.min(this.selectionStartCursorIdx, this.curCursorIdx), maxCursorIdx = Math.max(this.selectionStartCursorIdx, this.curCursorIdx);
+        if (minCursorIdx === maxCursorIdx) return "";
+        const config = this.rt.attribute.textConfig, startIdx = findConfigIndexByCursorIdx(config, Math.ceil(minCursorIdx)), endIdx = findConfigIndexByCursorIdx(config, Math.floor(maxCursorIdx));
+        let str = "";
+        for (let i = startIdx; i <= endIdx; i++) str += config[i].text;
+        return str;
+    }
     hasFormat(key) {
         return null != this.getFormat(key);
     }
-    getFormat(key) {
+    _getFormat(key, cursorIdx) {
+        var _a;
         if (!this.rt) return null;
-        const config = this.rt.attribute.textConfig, val = config[this.selectionStartCursorIdx + 1][key];
-        if (null == val) return null;
-        for (let i = this.selectionStartCursorIdx + 2; i <= this.curCursorIdx; i++) {
-            if (val !== config[i][key]) return null;
-        }
-        return val;
+        let idx = Math.round(cursorIdx);
+        const config = this.rt.attribute.textConfig;
+        for (let i = 0; i < config.length; i++) if ("\n" !== config[i].text && (idx--, idx < 0)) return config[i][key];
+        return null !== (_a = config[Math.min(idx, config.length - 1)][key]) && void 0 !== _a ? _a : this.rt.attribute[key];
+    }
+    getFormat(key) {
+        return this.getAllFormat(key)[0];
     }
     getAllFormat(key) {
-        if (!this.rt) return [];
-        const config = this.rt.attribute.textConfig, val = config[this.selectionStartCursorIdx + 1][key], set = new Set;
-        set.add(val);
-        for (let i = this.selectionStartCursorIdx + 2; i <= this.curCursorIdx; i++) {
-            const item = config[i];
-            set.add(item[key]);
+        const valSet = new Set, minCursorIdx = Math.min(this.selectionStartCursorIdx, this.curCursorIdx), maxCursorIdx = Math.max(this.selectionStartCursorIdx, this.curCursorIdx);
+        if (minCursorIdx === maxCursorIdx) return [ this._getFormat(key, minCursorIdx) ];
+        for (let i = Math.ceil(minCursorIdx); i <= Math.floor(maxCursorIdx); i++) {
+            const val = this._getFormat(key, i);
+            val && valSet.add(val);
         }
-        return Array.from(set.values());
+        return Array.from(valSet.values());
     }
 }
 
@@ -41,39 +58,57 @@ export const FORMAT_TEXT_COMMAND = "FORMAT_TEXT_COMMAND";
 export const FORMAT_ELEMENT_COMMAND = "FORMAT_ELEMENT_COMMAND";
 
 export class RichTextEditPlugin {
+    static tryUpdateRichtext(richtext) {
+        const cache = richtext.getFrameCache();
+        if (!RichText.AllSingleCharacter(cache)) {
+            const tc = RichText.TransformTextConfig2SingleCharacter(richtext.attribute.textConfig);
+            richtext.setAttributes({
+                textConfig: tc
+            }), richtext.doUpdateFrameCache(tc);
+        }
+    }
+    static CreateSelection(rt) {
+        if (!rt) return null;
+        const {textConfig: textConfig = []} = rt.attribute;
+        return new Selection(0, textConfig.length - 1, rt);
+    }
     constructor() {
         this.name = "RichTextEditPlugin", this.activeEvent = "onRegister", this._uid = Generator.GenAutoIncrementId(), 
-        this.key = this.name + this._uid, this.editing = !1, this.pointerDown = !1, this.handleInput = (text, isComposing, cursorIdx, rt, orient) => {
-            const p = this.getPointByColumnIdx(cursorIdx, rt, orient);
-            this.hideSelection(), this.setCursor(p.x, p.y1, p.y2), this.updateCbs.forEach((cb => cb("input", this)));
-        }, this.handleChange = (text, isComposing, cursorIdx, rt, orient) => {
-            const p = this.getPointByColumnIdx(cursorIdx, rt, orient);
-            this.curCursorIdx = cursorIdx, this.selectionStartCursorIdx = cursorIdx, this.setCursorAndTextArea(p.x, p.y1, p.y2, rt), 
-            this.hideSelection(), this.updateCbs.forEach((cb => cb("change", this)));
+        this.key = this.name + this._uid, this.editing = !1, this.pointerDown = !1, this.handleKeyDown = e => {
+            this.currRt && this.editing && (this.copyToClipboard(e) || this.fullSelection(e) || this.directKey(e));
+        }, this.handleInput = (text, isComposing, cursorIdx, rt) => {
+            this.hideSelection(), this.updateCbs.forEach((cb => cb("input", this)));
+        }, this.handleChange = (text, isComposing, cursorIdx, rt) => {
+            this.curCursorIdx = cursorIdx, this.selectionStartCursorIdx = cursorIdx;
+            const p = this.computedCursorPosByCursorIdx(cursorIdx, rt);
+            this.setCursorAndTextArea(p.x, p.y1, p.y2, rt), this.hideSelection(), this.updateCbs.forEach((cb => cb("change", this)));
+        }, this.handleFocusIn = () => {}, this.handleFocusOut = () => {
+            this.editing = !1, this.deFocus(), this.pointerDown = !1, this.triggerRender(), 
+            this.updateCbs.forEach((cb => cb("defocus", this)));
         }, this.handleMove = e => {
             this.isRichtext(e) && (this.currRt = e.target, this.handleEnter(e), e.target.once("pointerleave", this.handleLeave), 
-            this.showSelection(e));
-        }, this.handlePointerDown = e => {
-            this.editing ? this.onFocus(e) : this.deFocus(e), this.applyUpdate(), this.pointerDown = !0, 
-            this.updateCbs.forEach((cb => cb(this.editing ? "onfocus" : "defocus", this)));
-        }, this.handlePointerUp = e => {
-            this.pointerDown = !1;
+            this.tryShowSelection(e, !1));
         }, this.handleEnter = e => {
             this.editing = !0, this.pluginService.stage.setCursor("text");
         }, this.handleLeave = e => {
             this.editing = !1, this.pluginService.stage.setCursor("default");
+        }, this.handlePointerDown = e => {
+            this.editing ? this.onFocus(e) : this.deFocus(), this.triggerRender(), this.pointerDown = !0, 
+            this.updateCbs.forEach((cb => cb(this.editing ? "onfocus" : "defocus", this)));
+        }, this.handlePointerUp = e => {
+            this.pointerDown = !1;
+        }, this.handleDBLClick = e => {
+            this.editing && this.tryShowSelection(e, !0);
         }, this.commandCbs = new Map, this.commandCbs.set(FORMAT_TEXT_COMMAND, [ this.formatTextCommandCb ]), 
-        this.updateCbs = [];
-    }
-    getSelection() {
-        return this.selectionStartCursorIdx && this.curCursorIdx && this.selectionStartCursorIdx !== this.curCursorIdx && this.currRt ? new Selection(this.selectionStartCursorIdx, this.curCursorIdx, findCursorIndexIgnoreLinebreak(this.currRt.attribute.textConfig, this.selectionStartCursorIdx), findCursorIndexIgnoreLinebreak(this.currRt.attribute.textConfig, this.curCursorIdx), this.currRt) : null;
+        this.updateCbs = [], this.timeline = new DefaultTimeline, this.ticker = new DefaultTicker([ this.timeline ]), 
+        this.deltaX = 0, this.deltaY = 0;
     }
     formatTextCommandCb(payload, p) {
         const rt = p.currRt;
         if (!rt) return;
         const selectionData = p.getSelection();
         if (!selectionData) return;
-        const {selectionStartCursorIdx: selectionStartCursorIdx, curCursorIdx: curCursorIdx} = selectionData, config = rt.attribute.textConfig.slice(selectionStartCursorIdx + 1, curCursorIdx + 1);
+        const {selectionStartCursorIdx: selectionStartCursorIdx, curCursorIdx: curCursorIdx} = selectionData, minCursorIdx = Math.min(selectionStartCursorIdx, curCursorIdx), maxCursorIdx = Math.max(selectionStartCursorIdx, curCursorIdx), minConfigIdx = findConfigIndexByCursorIdx(rt.attribute.textConfig, minCursorIdx), maxConfigIdx = findConfigIndexByCursorIdx(rt.attribute.textConfig, maxCursorIdx), config = rt.attribute.textConfig.slice(minConfigIdx, maxConfigIdx);
         "bold" === payload ? config.forEach((item => item.fontWeight = "bold")) : "italic" === payload ? config.forEach((item => item.fontStyle = "italic")) : "underline" === payload ? config.forEach((item => item.underline = !0)) : "lineThrough" === payload ? config.forEach((item => item.lineThrough = !0)) : isObject(payload) && config.forEach((item => merge(item, payload))), 
         rt.setAttributes(rt.attribute);
     }
@@ -90,125 +125,102 @@ export class RichTextEditPlugin {
     activate(context) {
         this.pluginService = context, this.editModule = new EditModule, context.stage.on("pointermove", this.handleMove), 
         context.stage.on("pointerdown", this.handlePointerDown), context.stage.on("pointerup", this.handlePointerUp), 
-        context.stage.on("pointerleave", this.handlePointerUp), this.editModule.onInput(this.handleInput), 
-        this.editModule.onChange(this.handleChange);
+        context.stage.on("pointerleave", this.handlePointerUp), context.stage.on("dblclick", this.handleDBLClick), 
+        application.global.addEventListener("keydown", this.handleKeyDown), this.editModule.onInput(this.handleInput), 
+        this.editModule.onChange(this.handleChange), this.editModule.onFocusOut(this.handleFocusOut);
     }
-    showSelection(e) {
-        const cache = e.target.getFrameCache();
-        if (cache && this.editBg && this.pointerDown) {
-            let p0 = this.lastPoint, p1 = this.getEventPosition(e), line1Info = this.getLineByPoint(cache, p1);
-            const column1 = this.getColumnByLinePoint(line1Info, p1), y1 = line1Info.top, y2 = line1Info.top + line1Info.height;
-            let x = column1.left + column1.width, cursorIndex = this.getColumnIndex(cache, column1);
-            p1.x < column1.left + column1.width / 2 && (x = column1.left, cursorIndex -= 1), 
-            p1.x = x, p1.y = (y1 + y2) / 2;
-            let line0Info = this.getLineByPoint(cache, p0);
-            if ((p0.y > p1.y || p0.y === p1.y && p0.x > p1.x) && ([p0, p1] = [ p1, p0 ], [line1Info, line0Info] = [ line0Info, line1Info ]), 
-            this.editBg.removeAllChild(), line0Info === line1Info) {
-                const column0 = this.getColumnByLinePoint(line0Info, p0);
-                this.editBg.setAttributes({
-                    x: p0.x,
-                    y: line0Info.top,
-                    width: p1.x - p0.x,
-                    height: column0.height,
-                    fill: "#336df4",
-                    fillOpacity: .2
-                });
-            } else {
-                this.editBg.setAttributes({
-                    x: 0,
-                    y: line0Info.top,
-                    width: 0,
-                    height: 0
-                });
-                const startIdx = cache.lines.findIndex((item => item === line0Info)), endIdx = cache.lines.findIndex((item => item === line1Info));
-                let y = 0;
-                for (let i = startIdx; i <= endIdx; i++) {
-                    const line = cache.lines[i];
-                    if (i === startIdx) {
-                        const p = line.paragraphs[line.paragraphs.length - 1];
-                        this.editBg.add(createRect({
-                            x: p0.x,
-                            y: y,
-                            width: p.left + p.width - p0.x,
-                            height: line.height,
-                            fill: "#336df4",
-                            fillOpacity: .2
-                        }));
-                    } else if (i === endIdx) {
-                        const p = line.paragraphs[0];
-                        this.editBg.add(createRect({
-                            x: p.left,
-                            y: y,
-                            width: p1.x - p.left,
-                            height: line.height,
-                            fill: "#336df4",
-                            fillOpacity: .2
-                        }));
-                    } else {
-                        const p0 = line.paragraphs[0], p1 = line.paragraphs[line.paragraphs.length - 1];
-                        this.editBg.add(createRect({
-                            x: p0.left,
-                            y: y,
-                            width: p1.left + p1.width - p0.left,
-                            height: line.height,
-                            fill: "#336df4",
-                            fillOpacity: .2
-                        }));
-                    }
-                    y += line.height;
-                }
-            }
-            this.curCursorIdx = cursorIndex, this.setCursorAndTextArea(x, y1 + 2, y2 - 2, e.target), 
-            this.applyUpdate(), this.updateCbs.forEach((cb => cb("selection", this)));
+    copyToClipboard(e) {
+        if (application.global.isMacOS() && e.metaKey && "c" === e.key || !application.global.isMacOS() && e.ctrlKey && "c" === e.key) {
+            const text = this.getSelection().getSelectionPureText();
+            return application.global.copyToClipBoard(text), e.preventDefault(), !0;
         }
+        return !1;
     }
-    hideSelection() {
-        this.editBg && (this.editBg.removeAllChild(), this.editBg.setAttributes({
-            fill: "transparent"
-        }));
-    }
-    isRichtext(e) {
-        return !(!e.target || "richtext" !== e.target.type || !e.target.attribute.editable);
-    }
-    getEventPosition(e) {
-        const p = this.pluginService.stage.eventPointTransform(e), p1 = {
-            x: 0,
-            y: 0
+    selectionRange(startIdx, endIdx) {
+        const currRt = this.currRt;
+        if (!currRt) return;
+        const cache = currRt.getFrameCache();
+        if (!cache) return;
+        const {lines: lines} = cache, totalCursorCount = lines.reduce(((total, line) => total + line.paragraphs.length), 0) - 1;
+        startIdx > endIdx && ([startIdx, endIdx] = [ endIdx, startIdx ]), startIdx = Math.min(Math.max(startIdx, -.1), totalCursorCount + .1), 
+        endIdx = Math.min(Math.max(endIdx, -.1), totalCursorCount + .1), this.curCursorIdx = endIdx, 
+        this.selectionStartCursorIdx = startIdx;
+        const {x: x, y1: y1, y2: y2} = this.computedCursorPosByCursorIdx(this.selectionStartCursorIdx, this.currRt);
+        this.startCursorPos = {
+            x: x,
+            y: (y1 + y2) / 2
         };
-        return e.target.globalTransMatrix.transformPoint(p, p1), p1;
+        const pos = this.computedCursorPosByCursorIdx(this.curCursorIdx, this.currRt);
+        this.setCursorAndTextArea(pos.x, pos.y1, pos.y2, this.currRt), this._tryShowSelection(pos, cache);
     }
-    getLineByPoint(cache, p1) {
-        let lineInfo = cache.lines[0];
-        for (let i = 0; i < cache.lines.length && !(lineInfo.top <= p1.y && lineInfo.top + lineInfo.height >= p1.y); i++) lineInfo = cache.lines[i + 1];
-        return lineInfo;
+    fullSelection(e) {
+        if (application.global.isMacOS() && e.metaKey && "a" === e.key || !application.global.isMacOS() && e.ctrlKey && "a" === e.key) {
+            const currRt = this.currRt;
+            if (!currRt) return;
+            const cache = currRt.getFrameCache();
+            if (!cache) return;
+            const {lines: lines} = cache, totalCursorCount = lines.reduce(((total, line) => total + line.paragraphs.length), 0) - 1;
+            return this.selectionRange(-.1, totalCursorCount + .1), e.preventDefault(), !0;
+        }
+        return !1;
+    }
+    directKey(e) {
+        if ("ArrowUp" !== e.key && "ArrowDown" !== e.key && "ArrowLeft" !== e.key && "ArrowRight" !== e.key) return !1;
+        const cache = this.currRt.getFrameCache();
+        if (!cache) return !1;
+        let x = 0, y = 0;
+        "ArrowUp" === e.key ? y = -1 : "ArrowDown" === e.key ? y = 1 : "ArrowLeft" === e.key ? x = -1 : "ArrowRight" === e.key && (x = 1);
+        const {lineInfo: lineInfo, columnInfo: columnInfo} = this.getColumnByIndex(cache, Math.round(this.curCursorIdx)), {lines: lines} = cache, totalCursorCount = lines.reduce(((total, line) => total + line.paragraphs.length), 0) - 1;
+        if (x) {
+            x > 0 && columnInfo === lineInfo.paragraphs[lineInfo.paragraphs.length - 2] && this.curCursorIdx < Math.round(this.curCursorIdx) ? this.curCursorIdx = this.curCursorIdx + .2 : x > 0 && columnInfo === lineInfo.paragraphs[lineInfo.paragraphs.length - 1] && this.curCursorIdx > Math.round(this.curCursorIdx) ? this.curCursorIdx = this.curCursorIdx + 1 - .2 : x < 0 && columnInfo === lineInfo.paragraphs[0] && this.curCursorIdx > Math.round(this.curCursorIdx) ? this.curCursorIdx = this.curCursorIdx - .2 : x < 0 && columnInfo === lineInfo.paragraphs[0] && this.curCursorIdx < Math.round(this.curCursorIdx) ? this.curCursorIdx = this.curCursorIdx - 1 + .2 : this.curCursorIdx += x, 
+            this.curCursorIdx < -.1 ? this.curCursorIdx = -.1 : this.curCursorIdx > totalCursorCount + .1 && (this.curCursorIdx = totalCursorCount + .1);
+            const pos = this.computedCursorPosByCursorIdx(this.curCursorIdx, this.currRt);
+            this.setCursorAndTextArea(pos.x, pos.y1, pos.y2, this.currRt), this.hideSelection();
+        }
+        if (y) {
+            if (y > 0 && lineInfo === cache.lines[cache.lines.length - 1]) return;
+            if (y < 0 && lineInfo === cache.lines[0]) return;
+            const lineIdx = cache.lines.findIndex((item => item === lineInfo)) + y;
+            if (lineIdx < 0 || lineIdx >= cache.lines.length) return;
+            const pos = this.computedCursorPosByCursorIdx(this.curCursorIdx, this.currRt), posX = pos.x;
+            let posY = (pos.y1 + pos.y2) / 2;
+            posY += y * lineInfo.height;
+            const nextLineInfo = cache.lines[lineIdx], {columnInfo: columnInfo, delta: delta} = this.getColumnAndIndexByLinePoint(nextLineInfo, {
+                x: posX,
+                y: posY
+            });
+            if (!columnInfo) return;
+            let cursorIdx = this.getColumnIndex(cache, columnInfo) + delta;
+            const data = this.computedCursorPosByCursorIdx(cursorIdx, this.currRt);
+            cursorIdx < -.1 ? cursorIdx = -.1 : cursorIdx > totalCursorCount + .1 && (cursorIdx = totalCursorCount + .1), 
+            this.curCursorIdx = cursorIdx, this.selectionStartCursorIdx = cursorIdx, this.setCursorAndTextArea(data.x, data.y1, data.y2, this.currRt);
+        }
+        return !0;
     }
-    getColumnByLinePoint(lineInfo, p1) {
-        let columnInfo = lineInfo.paragraphs[0];
-        for (let i = 0; i < lineInfo.paragraphs.length && !(columnInfo.left <= p1.x && columnInfo.left + columnInfo.width >= p1.x); i++) columnInfo = lineInfo.paragraphs[i];
-        return columnInfo;
+    deactivate(context) {
+        context.stage.off("pointermove", this.handleMove), context.stage.off("pointerdown", this.handlePointerDown), 
+        context.stage.off("pointerup", this.handlePointerUp), context.stage.off("pointerleave", this.handlePointerUp), 
+        context.stage.off("dblclick", this.handleDBLClick), application.global.addEventListener("keydown", this.handleKeyDown);
     }
     onFocus(e) {
-        this.deFocus(e);
+        this.deFocus(), this.currRt = e.target;
         const target = e.target;
-        this.tryUpdateRichtext(target);
-        const shadowRoot = target.attachShadow();
-        shadowRoot.setAttributes({
-            shadowRootIdx: -1
-        });
-        const cache = target.getFrameCache();
+        RichTextEditPlugin.tryUpdateRichtext(target);
+        const shadowRoot = target.attachShadow(), cache = target.getFrameCache();
         if (!cache) return;
-        if (!this.editLine) {
+        if (this.computeGlobalDelta(cache), shadowRoot.setAttributes({
+            shadowRootIdx: 1,
+            pickable: !1,
+            x: this.deltaX,
+            y: this.deltaY
+        }), !this.editLine) {
             const line = createLine({
                 x: 0,
                 y: 0,
                 lineWidth: 1,
                 stroke: "black"
             });
-            line.animate().to({
-                opacity: 1
-            }, 10, "linear").wait(700).to({
-                opacity: 0
-            }, 10, "linear").wait(700).loop(1 / 0), this.editLine = line;
+            this.addAnimateToLine(line), this.editLine = line, this.ticker.start(!0);
             const g = createGroup({
                 x: 0,
                 y: 0,
@@ -217,28 +229,141 @@ export class RichTextEditPlugin {
             });
             this.editBg = g, shadowRoot.add(this.editLine), shadowRoot.add(this.editBg);
         }
-        const p1 = this.getEventPosition(e), lineInfo = this.getLineByPoint(cache, p1);
-        if (lineInfo) {
-            const columnInfo = this.getColumnByLinePoint(lineInfo, p1);
-            if (!columnInfo) return;
-            let y1 = lineInfo.top, y2 = lineInfo.top + lineInfo.height, x = columnInfo.left + columnInfo.width;
-            y1 += 2, y2 -= 2;
-            let cursorIndex = this.getColumnIndex(cache, columnInfo);
-            p1.x < columnInfo.left + columnInfo.width / 2 && (x = columnInfo.left, cursorIndex -= 1), 
-            this.lastPoint = {
+        const data = this.computedCursorPosByEvent(e, cache);
+        if (data) {
+            const {x: x, y1: y1, y2: y2, cursorIndex: cursorIndex} = data;
+            this.startCursorPos = {
                 x: x,
                 y: (y1 + y2) / 2
             }, this.curCursorIdx = cursorIndex, this.selectionStartCursorIdx = cursorIndex, 
             this.setCursorAndTextArea(x, y1, y2, target);
         }
     }
-    getPointByColumnIdx(idx, rt, orient) {
-        const cache = rt.getFrameCache(), {lineInfo: lineInfo, columnInfo: columnInfo} = this.getColumnByIndex(cache, idx);
-        let y1 = lineInfo.top, y2 = lineInfo.top + lineInfo.height;
-        return y1 += 2, y2 -= 2, {
-            x: columnInfo.left + ("left" === orient ? 0 : columnInfo.width),
-            y1: y1,
-            y2: y2
+    deFocus() {
+        const target = this.currRt;
+        target && (target.detachShadow(), this.currRt = null, this.editLine && (this.editLine.parent.removeChild(this.editLine), 
+        this.editLine.release(), this.editLine = null, this.editBg.parent.removeChild(this.editBg), 
+        this.editBg.release(), this.editBg = null));
+    }
+    addAnimateToLine(line) {
+        line.animates && line.animates.forEach((animate => {
+            animate.stop(), animate.release();
+        }));
+        const animate = line.animate();
+        animate.setTimeline(this.timeline), animate.to({
+            opacity: 1
+        }, 10, "linear").wait(700).to({
+            opacity: 0
+        }, 10, "linear").wait(700).loop(1 / 0);
+    }
+    tryShowSelection(e, dblclick) {
+        const cache = e.target.getFrameCache();
+        if (cache && this.editBg && this.startCursorPos) if (dblclick) {
+            const currCursorData = this.computedCursorPosByEvent(e, cache);
+            if (!currCursorData) return;
+            const lineInfo = currCursorData.lineInfo, columnIndex = lineInfo.paragraphs.findIndex((item => item === currCursorData.columnInfo));
+            if (columnIndex < 0) return;
+            const str = lineInfo.paragraphs.reduce(((str, item) => str + item.text), "");
+            let idx = 0;
+            for (let i = 0; i < cache.lines.length; i++) {
+                const line = cache.lines[i];
+                if (line === lineInfo) break;
+                idx += line.paragraphs.length;
+            }
+            const {startIdx: startIdx, endIdx: endIdx} = getWordStartEndIdx(str, columnIndex);
+            this.selectionRange(idx + startIdx - .1, idx + endIdx - .1);
+        } else if (this.pointerDown) {
+            const currCursorData = this.computedCursorPosByEvent(e, cache);
+            if (!currCursorData) return;
+            this.curCursorIdx = currCursorData.cursorIndex, this._tryShowSelection(currCursorData, cache);
+        }
+    }
+    _tryShowSelection(currCursorData, cache) {
+        let startCursorPos = this.startCursorPos, endCursorPos = {
+            x: currCursorData.x,
+            y: (currCursorData.y1 + currCursorData.y2) / 2
+        }, line0Info = this.getLineByPoint(cache, startCursorPos), line1Info = this.getLineByPoint(cache, endCursorPos);
+        if ((startCursorPos.y > endCursorPos.y || startCursorPos.y === endCursorPos.y && startCursorPos.x > endCursorPos.x) && ([startCursorPos, endCursorPos] = [ endCursorPos, startCursorPos ], 
+        [line1Info, line0Info] = [ line0Info, line1Info ]), this.hideSelection(), line0Info === line1Info) this.editBg.setAttributes({
+            x: startCursorPos.x,
+            y: line0Info.top,
+            width: endCursorPos.x - startCursorPos.x,
+            height: line0Info.height,
+            fill: "#336df4",
+            fillOpacity: .2
+        }); else {
+            this.editBg.setAttributes({
+                x: 0,
+                y: line0Info.top,
+                width: 0,
+                height: 0
+            });
+            const startIdx = cache.lines.findIndex((item => item === line0Info)), endIdx = cache.lines.findIndex((item => item === line1Info));
+            let y = 0;
+            for (let i = startIdx; i <= endIdx; i++) {
+                const line = cache.lines[i];
+                if (i === startIdx) {
+                    const p = line.paragraphs[line.paragraphs.length - 1];
+                    this.editBg.add(createRect({
+                        x: startCursorPos.x,
+                        y: y,
+                        width: p.left + p.width - startCursorPos.x,
+                        height: line.height,
+                        fill: "#336df4",
+                        fillOpacity: .2
+                    }));
+                } else if (i === endIdx) {
+                    const p = line.paragraphs[0];
+                    this.editBg.add(createRect({
+                        x: p.left,
+                        y: y,
+                        width: endCursorPos.x - p.left,
+                        height: line.height,
+                        fill: "#336df4",
+                        fillOpacity: .2
+                    }));
+                } else {
+                    const p0 = line.paragraphs[0], p1 = line.paragraphs[line.paragraphs.length - 1];
+                    this.editBg.add(createRect({
+                        x: p0.left,
+                        y: y,
+                        width: p1.left + p1.width - p0.left,
+                        height: line.height,
+                        fill: "#336df4",
+                        fillOpacity: .2
+                    }));
+                }
+                y += line.height;
+            }
+        }
+        this.setCursorAndTextArea(currCursorData.x, currCursorData.y1 + 2, currCursorData.y2 - 2, this.currRt), 
+        this.triggerRender(), this.updateCbs.forEach((cb => cb("selection", this)));
+    }
+    hideSelection() {
+        this.editBg && (this.editBg.removeAllChild(), this.editBg.setAttributes({
+            fill: "transparent"
+        }));
+    }
+    getLineByPoint(cache, p1) {
+        let lineInfo = cache.lines[0];
+        for (let i = 0; i < cache.lines.length && !(lineInfo.top <= p1.y && lineInfo.top + lineInfo.height >= p1.y); i++) lineInfo = cache.lines[i + 1];
+        return lineInfo;
+    }
+    getColumnAndIndexByLinePoint(lineInfo, p1) {
+        let columnInfo = lineInfo.paragraphs[0], delta = 0;
+        if (lineInfo.paragraphs.length) {
+            const start = lineInfo.paragraphs[0], end = lineInfo.paragraphs[lineInfo.paragraphs.length - 1];
+            p1.x <= start.left ? (delta = -.1, columnInfo = start) : p1.x >= end.left + end.width && (delta = .1, 
+            columnInfo = end);
+        }
+        if (!delta) for (let i = 0; i < lineInfo.paragraphs.length; i++) if (columnInfo = lineInfo.paragraphs[i], 
+        columnInfo.left <= p1.x && columnInfo.left + columnInfo.width >= p1.x) {
+            delta = p1.x > columnInfo.left + columnInfo.width / 2 ? .1 : -.1;
+            break;
+        }
+        return {
+            columnInfo: columnInfo,
+            delta: delta
         };
     }
     getColumnIndex(cache, cInfo) {
@@ -249,19 +374,25 @@ export class RichTextEditPlugin {
         }
         return -1;
     }
-    getColumnByIndex(cache, index) {
-        let inputIndex = -1;
-        for (let i = 0; i < cache.lines.length; i++) {
-            const lineInfo = cache.lines[i];
-            for (let j = 0; j < lineInfo.paragraphs.length; j++) {
-                const columnInfo = lineInfo.paragraphs[j];
-                if (inputIndex++, inputIndex === index) return {
-                    lineInfo: lineInfo,
-                    columnInfo: columnInfo
-                };
-            }
-        }
-        return null;
+    isRichtext(e) {
+        return !(!e.target || "richtext" !== e.target.type || !e.target.attribute.editable);
+    }
+    triggerRender() {
+        this.pluginService.stage.renderNextFrame();
+    }
+    computeGlobalDelta(cache) {
+        this.deltaX = 0, this.deltaY = 0;
+        const height = cache.height, actualHeight = cache.actualHeight, width = cache.lines.reduce(((w, item) => Math.max(w, item.actualWidth)), 0);
+        "center" === cache.globalAlign ? this.deltaX = -width / 2 : "right" === cache.globalAlign && (this.deltaX = -width), 
+        "middle" === cache.verticalDirection ? this.deltaY = height / 2 - actualHeight / 2 : "bottom" === cache.verticalDirection && (this.deltaY = height - actualHeight);
+    }
+    getEventPosition(e) {
+        const p = this.pluginService.stage.eventPointTransform(e), p1 = {
+            x: 0,
+            y: 0
+        };
+        return e.target.globalTransMatrix.transformPoint(p, p1), p1.x -= this.deltaX, p1.y -= this.deltaY, 
+        p1;
     }
     setCursorAndTextArea(x, y1, y2, rt) {
         this.editLine.setAttributes({
@@ -272,7 +403,7 @@ export class RichTextEditPlugin {
                 x: x,
                 y: y2
             } ]
-        });
+        }), this.addAnimateToLine(this.editLine);
         const out = {
             x: 0,
             y: 0
@@ -284,52 +415,59 @@ export class RichTextEditPlugin {
         const {left: left, top: top} = this.pluginService.stage.window.getBoundingClientRect();
         out.x += left, out.y += top, this.editModule.moveTo(out.x, out.y, rt, this.curCursorIdx, this.selectionStartCursorIdx);
     }
-    setCursor(x, y1, y2) {
-        this.editLine.setAttributes({
-            points: [ {
-                x: x,
-                y: y1
-            }, {
-                x: x,
-                y: y2
-            } ]
-        });
-    }
-    applyUpdate() {
-        this.pluginService.stage.renderNextFrame();
+    computedCursorPosByEvent(e, cache) {
+        const p1 = this.getEventPosition(e), lineInfo = this.getLineByPoint(cache, p1);
+        if (!lineInfo) return;
+        const {columnInfo: columnInfo, delta: delta} = this.getColumnAndIndexByLinePoint(lineInfo, p1);
+        if (!columnInfo) return;
+        let y1 = lineInfo.top, y2 = lineInfo.top + lineInfo.height;
+        y1 += 2, y2 -= 2;
+        let cursorIndex = this.getColumnIndex(cache, columnInfo);
+        cursorIndex += delta;
+        return {
+            x: columnInfo.left + (delta > 0 ? columnInfo.width : 0),
+            y1: y1,
+            y2: y2,
+            cursorIndex: cursorIndex,
+            lineInfo: lineInfo,
+            columnInfo: columnInfo
+        };
     }
-    deFocus(e) {
-        const target = this.currRt;
-        target && (target.detachShadow(), this.currRt = null, this.editLine && (this.editLine.parent.removeChild(this.editLine), 
-        this.editLine.release(), this.editLine = null, this.editBg.parent.removeChild(this.editBg), 
-        this.editBg.release(), this.editBg = null));
+    computedCursorPosByCursorIdx(cursorIdx, rt) {
+        var _a, _b, _c;
+        const idx = Math.round(cursorIdx), leftRight = cursorIdx - idx, cache = rt.getFrameCache(), column = this.getColumnByIndex(cache, idx), height = null !== (_a = rt.attribute.fontSize) && void 0 !== _a ? _a : null === (_c = null === (_b = rt.attribute.textConfig) || void 0 === _b ? void 0 : _b[0]) || void 0 === _c ? void 0 : _c.fontSize;
+        if (!column) return {
+            x: 0,
+            y1: 0,
+            y2: height
+        };
+        const {lineInfo: lineInfo, columnInfo: columnInfo} = column;
+        let y1 = lineInfo.top, y2 = lineInfo.top + lineInfo.height;
+        return y1 += 2, y2 -= 2, {
+            x: columnInfo.left + (leftRight < 0 ? 0 : columnInfo.width),
+            y1: y1,
+            y2: y2
+        };
     }
-    splitText(text) {
-        return Array.from(text);
-    }
-    tryUpdateRichtext(richtext) {
-        if (!richtext.getFrameCache().lines.every((line => line.paragraphs.every((item => !(item.text && isString(item.text) && this.splitText(item.text).length > 1)))))) {
-            const tc = [];
-            richtext.attribute.textConfig.forEach((item => {
-                const textList = this.splitText(item.text.toString());
-                if (isString(item.text) && textList.length > 1) for (let i = 0; i < textList.length; i++) {
-                    const t = textList[i];
-                    tc.push(Object.assign(Object.assign({}, item), {
-                        text: t
-                    }));
-                } else tc.push(item);
-            })), richtext.setAttributes({
-                textConfig: tc
-            }), richtext.doUpdateFrameCache(tc);
+    getColumnByIndex(cache, index) {
+        for (let i = 0, inputIndex = 0; i < cache.lines.length; i++) {
+            const lineInfo = cache.lines[i];
+            for (let j = 0; j < lineInfo.paragraphs.length; j++) {
+                const columnInfo = lineInfo.paragraphs[j];
+                if (inputIndex === index) return {
+                    lineInfo: lineInfo,
+                    columnInfo: columnInfo
+                };
+                inputIndex++;
+            }
         }
-    }
-    onSelect() {}
-    deactivate(context) {
-        context.stage.off("pointermove", this.handleMove), context.stage.off("pointerdown", this.handlePointerDown), 
-        context.stage.off("pointerup", this.handlePointerUp), context.stage.off("pointerleave", this.handlePointerUp);
+        return null;
     }
     release() {
-        this.editModule.release();
+        this.deactivate(this.pluginService), this.editModule.release();
+    }
+    getSelection(defaultAll = !1) {
+        return this.currRt ? null != this.selectionStartCursorIdx && null != this.curCursorIdx ? new Selection(this.selectionStartCursorIdx, this.curCursorIdx, this.currRt) : defaultAll ? RichTextEditPlugin.CreateSelection(this.currRt) : null : null;
     }
 }
 //# sourceMappingURL=richtext-edit-plugin.js.map